Langzahl-Arithmetik in BASIC

down Motivation

Euclid, Steindruck von Fiorini
Euclid (blühte ca. 300 B.C.)

Das auf dieser Seite präsentierte Material ist aufgrund meines Interesses an der Zahlentheorie entstanden. Es ist ein Forschungsgebiet woher vielen klassischen Algorithmen stammen, die man ohne Verzögerung implemen­tieren möge, um ihre Wirkungsmagie zu beobachten. Aber leider, sobald die Sachen fesselnd werden, gelangt man an die Grenzen, die das Gerät auferlegt:

‘[..] Die Anzahl von Symbole welche der Rechner in einem Moment beachten kann, ist beschrankt. Wenn er wünscht Mehre zu beachten, muß er aufein­ander folgenden Operationen verwenden.’ Alan Turing, Auf berechenbaren Zahlen [..], 1936.

Deshalb brauchte ich eine kleine Programmbibliothek, um die Grund­rechenarten in Bezug auf solche ‘aufeinander folgenden Operationen’ umzuformulieren. Anstatt eine von den vielen existierenden Langzahl­bibliotheken zu meinem Zweck anzupassen, schien es ausreichend um vorne anzufangen, und nur die notwendigsten Operationen durchzuführen.

Das Projekt wuchs unter eigenem Antrieb, einigen sehr nützlichen Funktionen werden zugefügt, aber unter Beibehalten des anfänglichen, einfachen Entwurfs. Die Bibliothek ist in reinem QuickBasic geschrieben, ergänzt mit Assembly-Schieberoutinen.

down Dateikopf der Langzahl-Bibliothek

' **************************************************************************
'Thema: Einfügeeinheit-Datei für eine Langzahl BASIC-Programmbibliothek.
'Autor: Sjoerd.J.Schaper
'Datum: 02-02-2004
'Code : QuickBasic, PDS, VBdos
' **************************************************************************

 (Siehe Download-Seite für Visual Basic/Win, FreeBasic und XBasic Versionen.)

' --------------------------------------------------------------------------
'   Dimensionen von Zahlen-Array n(uj, ui) ( nur für die $STATIC-Version )
' --------------------------------------------------------------------------
'CONST ui = 5, uj = 1418 '              langes Lib
CONST ui = 35, uj = 402 '              medium Lib
'CONST ui = 172, uj = 91 '              weites Lib
' --------------------------------------------------------------------------
'                            globale Konstanten
' --------------------------------------------------------------------------
CONST LB = 15, MB = 32768, MH = 16384 ' binär Speicherbasen
CONST M1 = 32767, M2 = 1073709056 '     Masken MB - 1, (MB - 1)* MB
CONST LD = 8, MD = 100000000 '          dezimale ein/aus Basen, MY < MB
CONST MY = 10000&, Fx = 2147483629 '    feste Limit
CONST t0 = -1, t1 = -2 '                Zeigern zu Wechsel-Spalten
CONST t2 = -3, t3 = -4
'
' **************************************************************************
'                      Initialisierung und Zuweisung
' **************************************************************************
'Die LargeInt-Klasse wird mit einem 'LargeInit(Größe%, Name$)' Aufruf am
'Modul-Niveau initialisiert. Für alle Langzahlen, die Sie verwenden wollen,
'sollen Sie konstante Indizes angeben ('CONST p = 0, q = 1, ..'), so daß
'jede Zahl mit einem eindeutigen Spaltenzeiger verbunden wird. Diese
'Zeigern werden dann den Prozeduren übergeben. Sie sollen keinen Funktions-
'Aufrufe mit gleichen Zeigern machen ('Squ p, p'), und sich hüten für
'Doppelverweisungen, weil diese Programmabstürze verursachen.
'
'In nachfolgenden Prototypen,
'sind die Buchstaben p, q, r, d, m  16-Bit Zeigern zur Langzahlen,
'die Variablen a, k, sw  16-Bit Ganzzahlen; c ist eine 32-Bit Ganzzahl;
'g ist eine Zahlzeichenkette; f und h sind irgendwelche Zeichenketten.
'
DECLARE FUNCTION LargeInit% (k AS INTEGER, f AS STRING)
'Initialisiert die Zahlen-Arrays, öffnet die Primzahltabelle und Logdatei.
'Auf zu rufen mit k = Anzahl der Largeint-Zahlen in ihrem Programm
'(k <= ui in der $STATIC-Version) und String f = Programm-Name. Wenn f = ""
'wird keine Logdatei geöffnet. Ruckgabewert ist die Largeint-Wortlänge.
'Die Maximallänge einer Dezimalzahl ist annäherend 4.51 * Wortlänge.
'
DECLARE SUB Letf (p AS INTEGER, c AS LONG)
'Weist Langzahl p den Doppelwortwert c zu.
'
DECLARE SUB Rndf (p AS INTEGER, k AS INTEGER)
'Weist p eine positive Zufallszahl mit Bitlänge Abs(k) zu.
'
DECLARE SUB Term ()
'Schließen der Primzahltabelle und Logdatei.
'
' **************************************************************************
'                        Funktionen zur Konvertierung
' **************************************************************************
DECLARE SUB Readst (p AS INTEGER, g AS STRING)
'Konvertiert die dezimale Zahlzeichenkette g in Langzahl p.
'Außer einem vorgesetzten Minuszeichen, gibt es keine Überprüfung
'auf Nichtziffer-Charaktere in der Zeichenkette.
'
DECLARE FUNCTION Decf% (p AS INTEGER)
'Konvertiert Langzahl p zur Basis MD in der Reihe ln().
'Gibt die Bytelänge von p zurück. An zu rufen bevor CnvSt.
'
DECLARE SUB CnvSt (g AS STRING)
'Konvertiert eine Zahl der Basis MD in eine Zahlzeichenkette.
'Rufen Sie erst k = Decf(p) auf, legen Sie einen Zeichenkettenpuffer
'g = STRING$(k, "0") an, und übergeben Sie diesen am CnvSt.
'
DECLARE FUNCTION Logf# (p AS INTEGER)
'Natürlicher Logarithmus von Langzahl Abs(p) in doppelte Genauigkeit.
'
DECLARE SUB Ratdec (g AS STRING, p AS INTEGER, q AS INTEGER)
'Gibt die Dezimaldarstellung von Zahlenverhältnis p / q in [0, 1)
'in Zahlzeichenkette g aus.
'
' **************************************************************************
'                              Datenausgabe
' **************************************************************************
DECLARE SUB Printf (f AS STRING, g AS STRING, h AS STRING, sw AS INTEGER)
'Druckt die Zeichenketten f, g und h zum Bildschirm und der Logdatei.
'Wenn sw = 1 wird eine CrLf, sw = 2 auch die Länge von g ausgegeben.
'
DECLARE SUB Printn (p AS INTEGER, f AS STRING, h AS STRING, sw AS INTEGER)
'Druckt Langzahl p ab mit Vorspann f und Schwanzende h, verwendet Printf.
'
DECLARE SUB Printr (p AS INTEGER, q AS INTEGER, r AS INTEGER, f AS STRING, _
 h AS STRING)
'Druckt die Dezimaldarstellung von Zahlenverhältnis p / q ab,
'die Dezimallänge wird in der Zahl r übergeben mit 'Setl r, len'.
'
DECLARE SUB Prints (f AS STRING, sw AS INTEGER)
'Druckt die Zeichenkette f ab,
'setzen Sie switch = 1 um ein CrLf an zu heften, switch = 2 für Zweier.
'
' **************************************************************************
'                       grundlegende Rechenfunktionen
' **************************************************************************
DECLARE FUNCTION Absf% (p AS INTEGER)
'Setzt das Vorzeichen von Zahl p auf 1, gibt den jetzigen Wert zurück.
'
DECLARE SUB Add (p AS INTEGER, q AS INTEGER)
'Addiert p und q, das Ergebnis steht in p.
'
DECLARE SUB Chs (p AS INTEGER)
'Veränderung des Vorzeichens von p.
'
DECLARE SUB Dcr (p AS INTEGER, a AS INTEGER)
'Vermindert Langzahl p mit dem positiven Kleinwert a.
'
DECLARE SUB Divd (p AS INTEGER, d AS INTEGER, q AS INTEGER)
'Dividiert p und d. Der Quotient steht in q, der Rest in p.
'
DECLARE SUB Inc (p AS INTEGER, a AS INTEGER)
'Erhöht Langzahl p mit dem positiven Kleinwert a.
'
DECLARE SUB Mult (p AS INTEGER, q AS INTEGER, r AS INTEGER)
'Multipliziert p und q. Das Ergebnis steht standardmäßig in p,
' 'Swp p, r' setzt es in r.
'
DECLARE SUB Powr (p AS INTEGER, k AS INTEGER)
'Potenziert Basis p mit Hochzahl k. Das Ergebnis steht in p.
'
DECLARE SUB Squ (p AS INTEGER, q AS INTEGER)
'Gibt das Quadrat von p in q zurück.
'
DECLARE SUB Subt (p AS INTEGER, q AS INTEGER)
'Subtrahiert q von p, das Ergebnis steht in p.
'Um p zu erhalten, verwenden Sie 'Subt q, p: Chs q'.
'
' **************************************************************************
'                          Vergleich und Kopieren
' **************************************************************************
DECLARE FUNCTION Cmp% (p AS INTEGER, q AS INTEGER)
'Vergleicht p und q:
'das Resultat ist -1 wenn p < q, 0 wenn p = q, und 1 wenn p > q.
'
DECLARE FUNCTION Isf% (p AS INTEGER, a AS INTEGER)
'Boolesch: überprüft ob Langzahl p den Kleinwert a gleich ist.
'
DECLARE FUNCTION Ismin1% (p AS INTEGER, m AS INTEGER)
'Boolesch: überprüft ob p = m - 1
'
DECLARE SUB Copyf (p AS INTEGER, q AS INTEGER)
'Kopiert Zahl p zu q.
'
DECLARE SUB Swp (p AS INTEGER, q AS INTEGER)
'Tauscht Zahlen p und q.
'
' **************************************************************************
'                             Bit-Verarbeitung
' **************************************************************************
DECLARE FUNCTION Bitl% (p AS INTEGER)
'Gibt die Bitlänge von Langzahl p zurück.
'
DECLARE SUB Boolf (p AS INTEGER, q AS INTEGER, k AS INTEGER)
'Bitweise boolesche Funktionen ergeben p:= q Op(k) p,
'mit Op(1) = AND, Op(2) = XOR, Op(3) = OR.
'Falls k = 0 wird NOT p zurückgegeben und q ignoriert.
'Jeweils bleibt das Vorzeichen von p unverändert.
'
DECLARE SUB Lsft (p AS INTEGER, k AS INTEGER)
'Langzahl p wird um k Bits nach links verschoben.
'
DECLARE SUB Rsft (p AS INTEGER, k AS INTEGER)
'Langzahl p wird um k Bits nach rechts verschoben.
'
' **************************************************************************
'                            Modular-Arithmetik
' **************************************************************************
DECLARE SUB Modbal (p AS INTEGER, m AS INTEGER)
'Gibt den ausgeglichenen Rest p Modul m: Abs(p) <= m \ 2.
'
DECLARE SUB Moddiv (p AS INTEGER, m AS INTEGER)
'Gibt den positiven Rest p Modul m.
'
DECLARE SUB Modmlt (p AS INTEGER, q AS INTEGER, m AS INTEGER)
'Multipliziert p und q, reduziert dann Modul m. Das Ergebnis steht in p.
'
DECLARE SUB Modpwr (p AS INTEGER, q AS INTEGER, m AS INTEGER)
'Modulares Potenzieren: Basis p, Hochzahl q, Modul m.
'Das Ergebnis steht in p.
'
DECLARE SUB Modsqu (p AS INTEGER, m AS INTEGER)
'Quadriert p, reduziert dann Modul m.
'
DECLARE FUNCTION Mp2% (p AS INTEGER, a AS INTEGER)
'Gibt Langzahl p Modul eine Einwortwert Potenz-von-Zwei zurück.
'
' **************************************************************************
'                      zahlentheoretische Funktionen
' **************************************************************************
DECLARE SUB Bezout (p AS INTEGER, q AS INTEGER, d AS INTEGER)
'Lösung der diophantische Gleichung px + qy = ggT(p, q).
'Positive x wird in p, y in q und ggT(p, q) in d zurückgegeben.
'
DECLARE SUB Euclid (p AS INTEGER, q AS INTEGER, d AS INTEGER)
'Der erweiterte Euklidische Algorithmus errechnet
'p^ -1 Mod q in p, q/ ggT in q und ggT(p, q) in d.
'
DECLARE SUB Fctl (p AS INTEGER, a AS INTEGER)
'Berechnet Fakultät a(a-1)···2·1 in Langzahl p.
'
DECLARE SUB Gcd (p AS INTEGER, q AS INTEGER, d AS INTEGER)
'Gibt der größte gemeinsame Teiler(p, q) in d zurück.
'
DECLARE FUNCTION IsPPrm% (p AS INTEGER, d AS INTEGER, k AS INTEGER)
'Boolesch: überprüft mit dem Test des Millers-Rabin ob p eine
'wahrscheinliche Primzahl ist. k ist die Anzahl des zu verwenden Zeuges.
'Falls es einen kleinen Teiler gibt, wird er in d zurückgegeben.
'
DECLARE FUNCTION IsSqr% (p AS INTEGER, q AS INTEGER)
'Boolesch: überprüft ob p ein Quadrat ist. Wenn wahr, ist die Wurzel in q.
'
DECLARE SUB Isqrt (p AS INTEGER, q AS INTEGER)
'Errechnet mit des Heronschen Algorithmus die Ganzzahl-Quadratwurzel von p,
'und gibt sie in q zurück.
'
DECLARE FUNCTION Kronec% (p AS INTEGER, q AS INTEGER, d AS INTEGER)
'Das quadratische Restsymbol Kroneckers (p/q) = 0, 1, oder -1.
'Gibt einen ungraden ggT(p, q) in d zurück, und 2 wenn er graden ist.
'
DECLARE SUB Lcm (p AS INTEGER, q AS INTEGER, d AS INTEGER)
'Gibt das kleinste gemeinsame Vielfache(p, q) in d zurück.
'
DECLARE FUNCTION Nxtprm& (sw AS INTEGER)
'Schleift durch Tabelle PrimFlgs.bin. Initiieren mit sw = 0 und
'Primzahl fortschreiben mit sw <> 0 bei jedem folgenden Aufruf.
'
DECLARE SUB Triald (q AS INTEGER, p AS INTEGER, c AS LONG)
'Probedivision von p bis Schranke c. Primfaktoren u/Exponenten werden
'in die Liste {q} gespeichert, der Restfaktor wird in p zurückgegeben.
'
' **************************************************************************
'                             direkter Zugrif
' **************************************************************************
DECLARE SUB EnQ (q AS INTEGER, p AS INTEGER, a AS INTEGER)
'Speichert kleine p und Einwortwert Abs(a) in sequentielle Liste {q}.
'Weil {q} negativen Trennzeichen enthält, wird ein einfaches Kommando
' Printn q, ...' Programmabstürz verursachen. Verwenden Sie stattdessen:
'
DECLARE FUNCTION ExQ% (p AS INTEGER, a AS INTEGER, q AS INTEGER, _
 k AS INTEGER)
'Herausziehen der sukzessiven Zahlen p und Abs(a) aus der Liste {q} mit
'Versetzung k. Initiieren mit k = 0, Wert ist Null wenn am Ende der Liste.
'
DECLARE FUNCTION Gete% (p AS INTEGER, k AS INTEGER)
'Gibt Array-Element Numero k der Zahl p zurück.
'Dies ist eine Ziffer in der Basis MB.
'
DECLARE FUNCTION Getl% (p AS INTEGER)
'Gibt die Anzahl der Array-Elemente für Zahl p zurück.
'
DECLARE FUNCTION Gets% (p AS INTEGER)
'Gibt das Vorzeichen der Zahl p zurück, Gets = -1 wenn p < 0, sonst 1.
'
DECLARE SUB Sete (p AS INTEGER, k AS INTEGER, a AS INTEGER)
'Setzt binär Array-Element Numero k von Zahl p auf Abs(a).
'
DECLARE SUB Setl (p AS INTEGER, a AS INTEGER)
'Setzt das Anzahl der Array-Elemente für p auf Abs(a).
'
DECLARE SUB Sets (p AS INTEGER, a AS INTEGER)
'Setzt das Vorzeichen von Zahl p auf Sgn(a + 0.5).
'
' **************************************************************************
'                            interne Funktionen
' **************************************************************************
DECLARE SUB Errorh (f AS STRING)
'Zeigt eine Fehlermeldung an.
'
DECLARE FUNCTION Hp2% (p AS INTEGER)
'Rückgabewert 2^ (höchste gesetzte bit im höchstwertigen Speicherwort von p).
'
DECLARE SUB Lftj (p AS INTEGER, k AS INTEGER)
'Langzahl p wird links justiert ab Array-Element k.
'
DECLARE FUNCTION PrimCeil& ()
'Rückgabewert ist die obere Begrenzung von Primzahltabelle PrimFlgs.bin.
'
DECLARE SUB Work (f AS STRING)
'Gibt das Arbeits-Dateiverzeichnis im ENVIRON$("LARGEINT") zurück.
'Der Puffer f soll genügend groß sein um den Pfad zu behalten.
'
' **************************************************************************
'             BASIC Prototypen für Maschinensprache-Unterstützung 
' **************************************************************************
DECLARE FUNCTION EstQ% (SEG a AS INTEGER, c AS LONG)
'( n(j, ..)·MB^2 + n(j-1, ..)·MB + n(j-2, ..) ) \ c
'45-bit Teilungszahl \ 30-bit Teiler.
'
DECLARE SUB Ffix ()
'Repariert den FWAIT Programmfehler ins Microsoft FPU Emulator-Library.
'
DECLARE SUB SftL (c AS LONG, k AS INTEGER)
'ShL long Integer c um k (mod 32) Bits.
'
DECLARE SUB SftR (c AS LONG, k AS INTEGER)
'ShR long Integer c um k (mod 32) Bits.
'
' **************************************************************************

down Übersicht der Module zur Zahlentheorie

Pierre Fermat, anonymer Stich
Pierre Fermat (1601-1665)

Mit der Programmbibliothek kommen einigen BASIC-Module betreffend die Zahlentheorie, die als Testumfeld dienen können. Lassen Sie sie laufen mit den Beispiel-Eingabedateien um Korrektheit und Leistung der Bibliothek zu zeigen. Alle Module sind im Englisch verfaßt.

Fibonacc.bas
Fibonacci-Zahlen und das Goldene Verhältnis phi.
Eine einfache Rekursiv definierte Reihe, Beispiel eines minimalen Moduls.
GaussEli.bas
Das Gaußsche Eliminationsverfahren in die Bareiss'sche divisionsfreie Version. Führt A in eine obere Dreiecksmatrix über und löst A·X = B
LDioSyst.bas
Lösung eines m x n (m ≤ n) linearen diophantischen Gleichungssystems unter Verwendung von Hermitesche- und Smithsche-Normalformen.
ExtEucli.bas
Kleinste Lösung der diophantischen Gleichung ax − by = c, auch bekannt als Identität Bézouts.
ChineseR.bas
Lösung eines Systems der linearen Kongruenzen.
Wendet der chinesische Restklassensatz an auf p gleichzeitige Kongruenzen ai·x ≡ bi Mod Mi.
QuadCngr.bas
Wurzeln einer quadratischen Kongruenz mit Primzahl-Modul N,
der Shanks-Tonelli Algorithmus (Ressol). Für r² ≡ -1 Mod N, wenn N ≡ 1 Mod 4 wird auch die Diophantische Gleichung x² + y² = N mit Algorithmus Cornacchias gelöst.
QuadForm.bas
Ganzzahlige binäre quadratische Form f =(a,±b,c) zur Diskriminante D,
die reduzierten Formen und zwei Darstellungen a = fred(x,y) werden ebenfalls ausgegeben.
Reprsent.bas
Lösungen der Diophantischen Gleichung ax² + bxy + cy² = N.
FundUnit.bas
Potenzdarstellung der Grundeinheit (p + q √d) / 2 eines quadratischen Zahlrings
K = Z(√d). Auch die Kettenbruchentwicklung und Dezimalnäherung der Quadratwurzel werden ausgegeben.
CnFcRoot.bas
Approximiert eine reale Wurzel des ganzzahligen Polynoms f(x)
mit der Kettenbruchmethode von Lagrange.
RadpAdic.bas
Die p-adische Wurzeln eines ganzzahligen Polynoms mit dem Henselschen Lemma.
Rational.bas
Der Kettenbruchalgorithmus.
Vereinfacht Zahlenverhältnisse und druckt Dezimalbrüche als gewöhnlichen Brüche aus.
ZnStruct.bas
Die Struktur der multiplikativen Einheitengruppe modulo n:
eine weitere Anwendung der Smithschen Normalform.
PrimRoot.bas
Überprüft ob die Basis a der Ordnung Phi(N) besitzt.
Geben Sie a = 1 ein um die kleinste Primitivwurzel von N zu finden.
TrialDiv.bas
Primfaktorzerlegung und Arithmetikfunktionen.
Errechnet die Eulersche φ-Funktion und Carmichaels λ-Funktion,
sowie die Divisorfunktionen μ(a), ω(a), Ω(a), δ(a) und σ(a).
GaussInt.bas
Eine Erweiterung des vorherigen Programms, um Gaußischen Zahlen zu verarbeiten.
PrimFlgs.bas
Das Sieb der Erathostenes: eine Variation von Chartres' Algorithmus 311.
Erzeugt eine kodierte Liste von Primzahlen, die durch die Bibliothek-Funktion Nxtprm() benutzt wird.
PollaRho.bas
Die Pollardsche Rho Monte-Carlo Faktorisierungsmethode, Änderung des Brents.
PollarP1.bas
Pollards Doppeltschritt P-1 Methode findet Faktor p von N, wenn p-1 ein Produkt ist von kleinen Primzahlen und einer einzelnen größeren Primzahl.
WilliaP1.bas
Die Doppeltschritt, Lucas-Folge P+1 Methode Williams findet einen Teiler p von N wenn alle Primteiler minus einen von p±1 höchstens B sind, und einem einzigen größeren Faktor höchstens B1 ist.
EllCrvFr.bas
Die elliptische-Kurven-Methode Lenstras (ECM) findet einen Teiler p von N, wenn irgendeiner elliptischen-Kurve Gruppenordnung p-Glatt ist.
FermatFr.bas
Zerlegung durch die Differenz zweier Quadrater.
Die Methode Fermats ist nützlich nur wenn N Teiler nah an seiner Quadratwurzel hat.
SquFoFac.bas
Quadratische Form-Faktorisierung des Shanks (SquFoF).
Wenn der Zyklus der reduzierten Formen ein nicht triviales ambiges Ideals enthält, könne die Diskriminante zerlegt werden.
DiscrLog.bas
Die Silver-Pohlig-Hellman Methode für den diskreten Logarithmus, verwendet Pollard Rho.
MASH-1.bas
Kryptographie: Modular-Arithmetik sichere Hash-Funktion.
Encoder.bas
Kryptographie: Potenzverschlüsselung mit Salze (RSA).
Decoder.bas
Entschlüsselung, der chinesische Restklassensatz verwendend.
Genrator.bas
Kryptographie: wahrscheinlichen Primzahlen und Schlüsselerzeugung.
Druckt relevante Werte zu den Öffentlichen- und Geheimschlüssel-Dateien.
NxtPrime.bas
Findet die folgende wahrscheinliche Primzahl ≥ N mit dem Miller-Rabin Test.
PowrModC.bas
Potenzieren von Gaußischen Zahlen: komplexe Basis und Modul, rationale Exponent.
Den Gaußischen Miller-Rabin Test wird ausgeführt für Exponent ‘N-1’.
PowrQbf.bas
Potenzieren von binären quadratischen Formen: Gaußische Komposition mit dem Nucomp-Algorithmus des Shanks.
Falls der Exponent k = 0 ist, werden Klassenzahlen berechnet mit Pollard-Teske Methoden für den diskreten Logarithmus.
PowrMtrx.bas
Pseudoprimzahltest für N unter Verwendung von rekurrenten Beziehungen der K-ter Ordnung,
potenzieren der Begleitmatrix M des charakteristischen Polynoms f(x).
LucasFun.bas
Der Lucas-Pseudoprimzahltest, schnelle Berechnung von Fibonacci-Riesen.
Mersenne.bas
Der Lucas-Lehmer-Test zum Prüfen von Mersenne-Zahlen 2^ p - 1,
mit p einer ungraden Prim. Spielzeugversion für kleines p.
WilsonTh.bas
Überprüfen ob eine Zahl Prim ist mit dem Theorem Wilsons:
iff p Prim, dann (p - 1)! ≡ -1 (mod p).
Goldbach.bas
Die Goldbach'sche Vermutung:
jede gerade Zahl größer als 2 ist die Summe von zwei Primzahlen.
Reciproc.bas
Reziproke einer kleinen Zahl, gibt Dezimalperioden der Maximallänge aus.
Kratsuba.bas
Karatsuba-Multiplikation, spielen mit einer rekursiven Prozedur.
Pi.bas
Pi-Berechnung mit der Formel von Gauß
π/4 = 12 * arctan(1/18) + 8 * arctan(1/57) - 5 * arctan(1/239).
Viele dieser Funktionen werden jetzt gesammelt in meinem
Umgekehrt polnische Notation (UpN) Langzahl-Taschenrechner.
 
C.F.Gauss, Steindruck von S. Bendixen (1828)
Karl Friedrich Gauss (1777-1855)
Herunterladen

Sehen Sie den Liesmich.txt ein

Spiegel Seite (in English)

Die Ackermannsche Funktion in Basic (English).

Es gibt auch einen Anhang: Arithmetik in endlichen Körper (English).

Wenn Sie ein interessantes Programm mit der Bibliothek geschrieben oder Verbesserungsvorschläge haben, laßt mich wissen. Wenn Sie Programm­fehler finden, berichten Sie mir bitte hier.

Lernen Sie über der Zahlentheorie auf Eric Weissteins großen
Welt der Mathematik oder der On-Line Wikipedia Enzyklopädie.

↑oben   Knoten
 

Buchliste:

Verzicht:

Dieser BASIC-Code für Langzahlen (großen Ganzzahlen, big numbers, grands nombres entiers, grandi numeri interi, números enteros grandes, inteiros grandes, μεγαλοι ακεραιοι αριθμοι usw.) wird kostenlos verteilt in die Hoffnung daß es nützlich sein wird, aber ohne Garantie jeder Art, sogar die implizierte Garantie der Marktgängigkeit oder Angemessenheit zu einem bestimmten Zweck. Erlaubnis ist bewilligt für das Ändern Ihrer Kopie des Codes oder die Formung einer nicht-kommerziellen Anwendung, die auf ihn basiert, und solche Kopien und Änderungen zu verteilen, vorausgesetzt daß der geänderte Inhalt einen Hinweis auf dem Urheber des Quellcodes und Nachrichten angebend trägt, daß er geändert worden ist und von wem.

Gültiges xhtml 1.0! Gültiges css! SourceForge.net logo Copyright © december 2003 Sjoerd J. Schaper