Funktionstests, 5000-stelliger Rechner

Test der Funktionen im 5000-stelligen Taschenrechner
Die Funktionen sind in alphabetischer Reihenfolge der DM-Funktionsnamen aufgeführt, wobei einige
Funktionen, z. B. SIN, COS und TAN unter dem ersten Namen zusammengefasst sind und auch BINK, BINV
und KBNV stehen hintereinander. Auch die hier noch nicht aufgeführten Funktionen sind natürlich getestet
worden, jedoch hier noch nicht dokumentiert.
Die Basis des 5000-stelligen Taschenrechners ist ein Programms von David M. Smith. Neben den
Standardoperationen sind in diesem Programm auch eine Reihe von Standardfunktionen enthalten.
Berechnungen in DM werden immer in der vorgegebenen Weise durchgeführt. DM ist nicht in der Lage,
Vereinfachungen, z. B. bei LN(EXP(X))-1, durchzuführen. Das gefundene Ergebnis 0 für den Ausdruck ist
daher ein Test für den Logarithmus und die Exponentialfunktion.
Die Berechnungen wurden mit dem für das gewünschte Ergebnis notwendigen Einstellungen für die
Rechengenauigkeit durchgeführt.
Die Zusammenstellung beschreibt in der angegebenen Reihenfolge:
BINK:
BINV:
KBNV:
DIV:
LEG:
ALEG:
NPRI:
PIPR:
POCH:
POIS:
SIN:
COS:
TAN:
STIE:
STIZ:
SUM:
TEFU:
TEZA:
PTZA:
Binomialkoeffizienten
Binomialverteilung
Kumulierte Binomialverteilung
Ganzzahldivision
Legendre-Polynome
Assoziierte Legendre-Polynome
N-te Primzahl
Zahl der Primzahlen bis zum Argument
Pochhammersymbol
Poissonverteilung
Sinus
Cosinus
Tangens
Stirlingzahlen 1. Art
Stirlingzahlen 2. Art
Endliche und unendliche Summen
Teilerfunktion
Teilerzahl
Primteilerzahl
BINK(N,K)
Berechnet die Binomialkoeffizienten N über K. Aufruf BINK(N,K).
Definition: BINK(N,K) = N!/(K! (N-K)!)
Beschränkungen: N und K ganzzahlig und größer gleich 0, sonst Fehlermeldung.
In Übereinstimmung mit Mathematica ist:
BINK(5,0) = 1 wegen 5!/(0! 5!) = 5!/5 = 1
BINK(0,5) = 0. Das ist nicht ohne weiteres ersichtlich.
BINK(0,0) = 1 wegen 0!/(0! 0!) = 1
BINK(5,5) = 1 wegen 5!/(5 0!) = 1
Fall K > N BIN K in Übereinstim m u ng m it M a them a tica = 0. Für diese Argumente sind die
Binomialkoeffizienten nicht definiert (siehe z. B. Num. Rec. S. 208).
Mathematica gibt auch Binomialkoeffizienten für den Fall N < 0 aus. Dies erfolgt nicht in DM in
Übereinstimmung mit der Nichtausgabe von Fakultäten für Argumente < 0.
Zur Berechnung wird eine Rekursion aus Num. Rec. S. 209, Gl. 6.1.7 benutzt.
In diesem Ausdruck wird k durch k - 1 ersetzt:
Sie gestattet die Berechnung von N über K ausgehend von N über 0 = 1. Für die Berechnung wird weiterhin die
Symmetrie ausgenutzt. Das Pascalsche Dreieck ist symmetrisch zur Mitte, d. h. man darf mit K oder N - K
rechnen - dies folgt auch aus der obigen Definition. Da die Rekursion über K läuft, kann dies eine wesentliche
Erhöhung der Geschwindigkeit und Genauigkeit nach sich ziehen.
Einige Werte mit kleineren Argumenten wurden manuell nachgerechnet:
BINK(5,3) = 10
BINK(8,4) = 70
BINK(9,4) = 126
Einige größere Werte in Übereinstimmung mit Mathematica. Es sind nur der Anfang and das Ende der ganzen
Zahlen angegeben.
BINK(120,40) = 114556.....471
BINK(300,123) = 7193.....99288000 (7. ... @10 86)
BINK(1030,515) = 285964........9057400 (2.8..... @ 10 308)
BINV
Berechnet den Wert der Binomialverteilung mit der Definition
Die Berechnung erfolgt entsprechend dieser Definition, wobei für zur Berechnung von N über K die Routine aus
der Funktion BINK verwendet wird. Probleme bei der Berechnung durch sich weitgehend aufhebende Terme
sind hier nicht zu befürchten.
Beschränkungen: N und K ganzzahlig und größer gleich 0, p zwischen 0 und 1, K kleiner gleich N, sonst
Fehlermeldung.
Zwei Sonderfälle für N=1 und größer müssen wegen 0^0 gesetzt werden:
BINV(N,0,0) = 1
BINV(N,N,1) = 1
Sonderfall so gesetzt:
BINV(0,0,p) = 1 für alle p.
Ein mit Hand nachgerechneter Wert:
BINV(5,3,0.3) = 10 @ 0.3 3 @ 0.7 2 = 0.132300000....
BINV(15,5,0.2) - 3003 * 0.2 5 * 0.8 10 = 0
BINV(1030,515,0.2) - BINK(1030,515)*0.16^515 = 0
Die Summe der Binomialverteilungen über alle K muss 1 ergeben:
SUM(0,30,BINV(30,MIN(30,J),0.34567))-1 = 0; auch mit 300 und entsprechender Stellenzahl wird eine Null
berechnet. Der Term MIN(30,J) an Stelle von J ist notwendig, um J nicht auf 31 wachsen zu lassen: siehe
Bemerkung bei SUM in der DM-Hilfe.
KBNV
Berechnet den Wert der kumulierten Binomialverteilung mit der Definition
Die Berechnung erfolgt entsprechend dieser Definition, wobei für N über M die Routine aus der Funktion BINK
verwendet wird. Probleme bei der Berechnung durch sich weitgehend aufhebende Terme sind hier nicht zu
befürchten.
Beschränkungen: N und K ganzzahlig und größer gleich 0, p zwischen 0 und 1, K kleiner gleich N, sonst
Fehlermeldung.
Zwei so gesetzte Sonderfälle für N=1 und größer:
KBNV(N,0,0) = 1
KBNV(N,N,1) = 1
Sonderfall so gesetzt:
KBNV(0,0,p) = 1 für alle p.
Einige mit Hand nachgerechnete Werte:
KBNV(5,3,0.3) = 0.96922000000
KBNV(5,5,0.3) = 1
KBNV(15,5,0.2) = 0.9389485703823360000000.....
Weiterhin wurden einige Werte mit dem Taschenrechner entsprechend ihrer Definition überprüft. Z. B.
KBNV(15,5,0.2)-SUM(0,5,BINK(15,J)*0.2^J*(1-0.2)^(15-J))
oder ähnlich
KBNV(15,5,0.2)-SUM(0,5,BINV(15,J,0.2))
Ergebnis: 0
KBNV(1030,1030,0.2) = 1.
DIV(N,M )
Ergibt die Ganzzahldivision von N/M.
N und M müssen ganzzahlig sein, M ungleich 0; andernfalls Fehlermeldung.
Einige Ergebnisse:
DIV(12,3) = 4
DIV(13,3) = 4
DIV(14,3) = 4
DIV(-13,3) = -4
DIV(13,-3) = -4
DIV(-13,-3) = 4
SQRT(DIV(1234567890123456789^2*123456789012345678+1,123456789012345678)) ergibt
1234567890123456789
d. h. SQRT(DIV(X^2*Y+1,Y)) = X
LEG(l,X)
Berechnet den Funktionswert des Legendre-Polynoms P l(x). Der Index l muss ganzzahlig und 0 # l #
2147483647 sein.
Für die Berechnung des Funktionswertes gibt es explizite Gleichungen, die bei großen l und X große Terme mit
wechselnden Vorzeichen aufweisen und daher zu groben Fehlern bei beschränkter Rechengenauigkeit führen.
Besser ist die Verwendung der stabilen Rekursion
die auch für die assoziierten Legendre-Polynome verwendet werden kann. Hier wird m = 0 gesetzt. Die
Startwerte sind P 0(x) = 1 und P 1(x) = x.
Einige Werte:
LEG(0,1.7) = 1
LEG(1,1.7) = 1.7
LEG(1,-1.7) = -1.7
LEG(2,SQRT(2)) = 0.5*(3*2-1) = 2.5
LEG(10,2) = 96060.5195312500000
LEG(100,3) = 2053716. . . . 43041
LEG(1000,50) = 1614. . . . .070329.8
in Übereinstimmung mit Mathematica
Ergebnis ist ganzzahlig
(.2 @10 75)
bei 2000-stelliger Ausgabe (.1.6 @10 1998)
ALEG(l,m,X)
Berechnet den Funktionswert des assoziierten Legendre-Polynoms P lm(x). Die Indices l und m müssen
ganzzahlig und 0 # l,m # 2 147 483 647 sein. Das absolute Argument *X* muss # 1 sein.
Für die Berechnung des Funktionswertes gibt es explizite Gleichungen, die bei großen l und X große Terme mit
wechselnden Vorzeichen aufweisen und daher zu groben Fehlern bei beschränkter Rechengenauigkeit führen.
Besser ist die Verwendung der stabilen Rekursion
Die Startwerte sind Pmm(x) und P m+1m(x), für die es einfache Ausdrücke gibt.
ALEG(1,1,SQRT(0.5)) = -(1 - 0.5)^0.5 = - 0.7071068 . . . . .
ALEG(2,1,SQRT(0.5)) = -3 (1 - 0.5)^0.5*0.5^0.5 = - 3*0.5^0.5*0.5^0.5 = - 3*0.5^1 = -1.5
ALEG(2,3,X) = 0
ALEG(10000,10,0.7) = - 5.819 062 432 628 616 . . . @10 37 in Übereinstimmung mit Mathematica
NPRI(N)
NPRI(N) ergibt die N. Primzahl, ist also quasi invers zu PIPR(N). Ein direktes Berechnungsverfahren für diese
Funktion gibt es nicht; es muss leider die Zahl der Primzahlen ausgezählt werden. Das Ergebnis ist auf den
Bereich der INTEGER*4-Zahlen, d. h. auf 2147483647, beschränkt; dementsprechend darf das Argument von
NPRI höchstens 105097565 betragen.
Auch für diesen Zahlenbereich würden die Berechnungen sehr lange dauern. In DM gibt es daher das File
PRIM.DAT, das B(N) für 1000000 und Vielfache davon enthält. Der Algorithmus liest dieses File und
vergleicht mit N. Der Algorithmus benutzt dann diese Stützstelle, bzw. die vorangehende, und zählt von dort ab.
Weiterhin werden Ergebnisse von vorgehenden Berechnungen für kleinere N benutzt.
Zur Feststellung, ob eine Zahl eine Primzahl ist oder nicht, wird wie folgt vorgegangen. Beim Start wird mit
Hilfe des Siebs des Eratosthenes eine Liste der Primzahlen bis 1000000 angelegt. Dann wird die Teilbarkeit der
untersuchten Zahl durch die Primzahlen dieser Liste bis zur der Primzahl untersucht, die größer als die Wurzel
aus der gegebenen Zahl ist.
N muss ganzzahlig und 1 # N # 105097565 sein.
NPRI(0) = Fehlermeldung
NPRI(1) = 2
NPRI(2) = 3
NPRI(100) = 541
NPRI(1000) = 7919
NPRI(10000) = 104729
NPRI(78498) = 999983
NPRI(78499) = 1000003
NPRI(78498) = 1000033
Sprung über eine Stützstelle. Dass diese Zahlen aufeinander folgende PrimZahlen sind, kann man sich in Mathematik/Mengen aus der Zahlentheorie/Primzahlen/Primzahlen ansehen.
NPRI(100000) = 1299709
NPRI(300000) = 4256233
NPRI(1000000) = 15485863
NPRI(10000000) = 179424673
NPRI(105097565) = 2147483647
NPRI(105097564) = 2147483629
PIPR(100) =
PIPR(101) =
PIPR(102) =
PIPR(103) =
PIPR(102) =
PIPR(101) =
541
547
557
563
557
547
PIPR(NPRI(X)) -X = 0
Benutzung von vorangehenden Berechnungen
X ganzzahlig und $ 1
PIPR(N)
PIPR(N), üblicherweise als B(N) bezeichnet, gibt die Zahl der Primzahlen kleiner gleich N aus. Ein direktes
Berechnungsverfahren für diese Funktion gibt es nicht; die Zahl der Primzahlen bis zu einem bestimmten N
muss leider gezählt werden. Für den Bereich der INTEGER*4-Zahlen, d. h. bis 2147483647, würde dies für
größere Zahlen sehr lange dauern. In DM gibt es daher das File PRIM.D AT , das B(N) für 1000000 und
Vielfache davon enthält, so dass nur jeweils vom nächst kleineren Vielfachen von 1000000 aus gezählt werden
muss. Weiterhin werden Ergebnisse von vorgehenden Berechnungen für kleinere N benutzt.
Zur Feststellung, ob eine Zahl eine Primzahl ist oder nicht, wird wie folgt vorgegangen. Beim Start wird mit
Hilfe des Siebs des Eratosthenes eine Liste der Primzahlen bis 1000000 angelegt. Dann wird die Teilbarkeit der
untersuchten Zahl durch die Primzahlen dieser Liste bis zur der Primzahl untersucht, die größer als die Wurzel
aus der gegebenen Zahl ist.
N darf in DM auch nicht ganzzahlig sein; es darf jedoch 2147483647 nicht überschreiten. Größere Werte für
N würden zu nicht akzeptablen Rechnezeiten führen. Im Prinzip wird daher nur die Routine aus dem normalen
Taschenrechner benutzt.
Einige Ergebnisse, die in DM und Mathematica übereinstimmen.
PIPR(1) = 0
PIPR(2) = 1
PIPR(3) = 2
PIPR(4) = 2
PIPR(5) = 3
PIPR(6) = 3
PIPR(7) = 4
PIPR(7.0001) = 4
PIPR(6.9999) = 3
PIPR(50000) = 5133
PIPR(999998) = 78498
Zählung der Primzahlen von 2 ab
PIPR(999999) = 78498
Zählung der Primzahlen von 2 ab
PIPR(1000000) = 78498
Nutzung der Stützstelle bei 1000000
PIPR(1000010) = 78499
Nutzung der Stützstelle bei 1000000 und Weiterzählung (1000003 ist prim)
PIPR(1000101) = 78504
Nutzung der Stützstelle bei 1000000 und Weiterzählung
PIPR(2000000) = 148933
Nutzung der Stützstelle bei 2000000
PIPR(20000000) = 1270607
PIPR(200000000) = 11078937
PIPR(2147483647) = 105097565
PIPR(2147483646) = 105097564
PIPR(2147483629) = 105097564
PIPR(2147483627) = 105097563
PIPR(N#0) = 0
PIPR(NPRI(X)) -X = 0
PIPR(200) =
PIPR(240) =
PIPR(280) =
PIPR(320) =
PIPR(280) =
PIPR(240) =
46
52
59
66
59
52
X ganzzahlig und $ 1
Berechnung unter Zuhilfenahme des vorigen Ergebnisses
Berechnung unter Zuhilfenahme des vorigen Ergebnisses
Berechnung unter Zuhilfenahme des vorigen Ergebnisses
Neuberechnung
Neuberechnung
PIPR(X)/LI(X) strebt für große X gegen 1.
PIPR(NPRI(X)) -X = 0
X ganzzahlig und $ 1
Die Primzahlmenge kann man sich auch bei Mathematik/Mengen aus der Zahlentheorie/Primzahlen/Primzahlen
ansehen. Hier wird neben der Zahl auch die Primzahlmenge selbst ausgegeben.
POCH(X,N)
Das Pochhammersymbol ergibt die aufsteigende Fakultät beginnend mit dem Glied X. Das zweite Argument N
beschreibt die Gliedzahl, d. h.
X*(X+1)*(X+2)* . . . *(X+N-1)
X ist eine beliebige REAL-Zahl; N ist ganzzahlig und absolut # 100 000 000. Für negative N benutzt man die
auch für positive N gültige Definition '(X+N)/'(X). Dies ergibt für negative N den Reziprokwert der
absteigenden Fakultät von X-1 bis X+N, d. h. POCH(17,-2) = 1/(16*15).
Wird für negative Argumente X ein Produktterm Null, so ist POCH Null. Wird für negative N ein Divisionsterm
Null, erfolgt eine Fehlermeldung.
POCH(17.3,0) = 1 So gesetzt.
POCH(17.3,1) = 17.3
POCH(3,4) = 360
POCH(22.2,154) = 3.346592715260669288684 . . .@10 298
POCH(-5,2) = 20
POCH(-5,3) = -60
POCH(-6,8) = 0
POCH(5,-2) = 1/(4*3) = 0.0833333
POCH(5,-6):
Fehlermeldung: Division durch Null
POCH(-10,-3) = 1/{(-11) (-12) (-13)} = -0.000582750 . (____ = Periode)
POIS(N, ARG2)
Poissonverteilung, ergibt ARG2^N*EXP(-ARG2)/N! mit einer rekursiven Berechnung. N ganzzahlig und 0 #
N # 2 147 483 647, Mittelwert/Varianz ARG2 > 0.
Die rekursive Berechnung wurde gewählt, da man mit sehr großen ARG2^N und N! aus dem Bereich der
Bereich der REAL-Zahlen herauslaufen kann. Die Rekursion ist
POIS(N+1,X) = X/(N+1)*POIS(N,X) mit dem Startwert POIS(0,X) = EXP(-X)
Tests:
Vergleich mit der Definition
POIS(0,3) - EXP(-3) = 0
POIS(3,2.3) - 2.3^3*EXP(-2.3)/FAK(3) = 0
POIS(50,50)-POIS(49,50) = 0
POIS(600,590)-590^600/FAK(600)*EXP(-590) = -1.36 @ 10 -1528 mit 1500-stelliger Genauigkeit
SIN, COS und TAN
Berechnet die trigonometrischen Funktionen des Arguments. Hier werden die Funktionen des Programms von
David M. Smith benutzt, das die Basis des 5000-stelligen Taschenrechner bildet. Steht die Checkbox auf Grad,
so wird in der Klammer mit GRADBOG multipliziert.
In DM findet man korrekt entsprechend der eingestellten Genauigkeit
SIN(PI/2) = 1
SIN(-PI/2) = -1
SIN(5*PI/2) = 1
ASIN(SIN(X)) - X = 0 mit X = krummer Wert größer/kleiner als 0
COS(PI) = 1
COS(-PI) = -1
COS(5*PI) = -1
TAN(PI/4) = 1
SIN(45) - SQRT(2)/2 = 0 Im Gradmaß
COS(45) - SQRT(2)/2 = 0
SIN(60) - SQRT(3)/2 = 0
COS(30) - SQRT(3)/2 = 0
SIN(X)^2 + COS(X)^2 = 1 X = krumme Gradzahl
TAN(X) - SIN(X)/COS(X) = 0
SIN(2*X) - 2*SIN(X)*COS(X) = 0
SIN(10000*PI) = 0
Der Tangens ergibt bei 90° keinen Absturz, sondern:
Bei Berechnung im Bogenmaß mit 50 Stellen: TAN(PI/2) = 2.2*10 77
Bei Berechnung im Gradmaß mit 50 Stellen:
TAN(90) = keine Ausgabe, wegen Nichtweiterverarbeitung
einer internen Fehlermeldung.
STIE(N,K)
STIE(N,K) berechnet die Stirlingschen Zahlen 1. Art mit Vorzeichen. N muss # 2147483647 sein; K muss #
500 sein; sie müssen ganzzahlig sein und den Bedingungen 1 # N und 1 # K # N genügen. Die Grenze 500 für
K hängt mit der Maximalzahl von Zwischenspeicherungen für die Rekursion zusammen.
Die Stirlingschen Zahlen 1. Art werden mit der folgenden programmierten Rekursion berechnet:
STIE(N,K) = STIE(N-1,K-1) - (N-1)*STIE(N-1,K)
Einige Werte sind in der folgenden T abelle zusammengestellt, die man mit Mathematica erhält oder auch
anderswo findet.
K
N
1
2
3
4
5
6
1
2
3
4
5
6
1
-1
2
-6
24
-120
1
-3
11
-50
274
1
-6
35
-225
1
-10
85
1
-15
1
Einige größere Werte, mit Mathematica überprüft:
STIE(10,5) = -269325
STIE(15,5) = 159721605680
STIE(18,5) = -909299905844112
STIE(40,21) = -66803578934102519403022344228441000
STIE(100,50) = +318322278235296438474435412072968606417560943939705506371757/
8668769227113071836382198739697421125692626030268475
Einige Zusammenhänge:
In DM: PROD(0,9,X-J) - SUM(1,10,STIE(10,J)*X^J) ergibt Null für verschiedene X.
In DM: SUM(1,X,(-1)^J*STIE(X,J)) - (-1)^X*FAK(X) mit verschiedenen ganzen X ergibt Null.
Die vorzeichenlosen Stirlingschen Zahlen 1. Art erhält man mit ABS(STIE(N,K)).
STIZ(N,K)
STIZ(N,K) berechnet die Stirlingschen Zahlen 2. Art. N und K müssen kleiner gleich 2147483647 sein; sie
müssen ganzzahlig sein und den Bedingungen 0 <= N und 0 <= K <= N genügen.
Der Fall N = 0, K = 0 (Ergebnis 1) wird gesondert gesetzt. Die restlichen Stirlingschen Zahlen 2. Art werden
mit der expliziten Gleichung
berechnet:
Einige Werte sind in der folgenden Tabelle zusammengestellt, die man mit Mathematica erhält oder auch
anderswo findet.
K
N
0
1
2
3
4
5
6
0
1
2
3
4
5
6
1
0
0
0
0
0
0
1
1
1
1
1
1
1
3
7
15
31
1
6
25
90
1
10
65
1
15
1
Einige größere Werte, mit Mathematica überprüft:
STIZ(10,6) = 22827
STIZ(15,5) = 210766920
STIE(22,11) = 366282500870286
STIE(100,55) = 4475. . . . 44000
(4.4@10 95)
STIE(200,100) = 22839 . . . . . 07556
(2.2@10 234)
Einige Zusammenhänge:
In DM: STIZ(X,X-1) - BINK(X,2) ergibt Null für verschiedene ganze X. X = 109 ergibt die Null nur mit
entsprechend vielen Stellen bei der Berechnung oder man rechnet mit Stellenanpassung.
In DM: STIZ(X,2)-(2^(X-1)-1) ergibt Null für verschiedene ganze X.
Die Rekursionsformel
In DM: STIZ(100,X) - (STIZ(100-1,X-1) + X*STIZ(100-1,X)) und z. B. X = 10 ergibt Null bei entsprechend
großer Stellenzahl oder mit Stellenanpassung.
SUM (NU,NO,F(J))
Berechnet endliche und unendliche Summen, Aufruf SUM(NU,NO,F(J)), untere Summengrenze NU und obere
Summengrenze NO, F(J) ist eine beliebige Funktion der Laufzahl J.
Die Summengrenzen müssen ganzzahlig sein; die obere Grenze NO muss größer gleich der unteren NU sein.
Test einiger endlicher Summen:
SUM(1,50,FAK(J)*J)-(FAK(51)-1) = 0
SUM(1,100,J^3)-(100*101/2)^2 = 0
Test mit einigen unendlichen Summen:
Summe über 1/N! von 0 bis unendlich = e
SUM(0,1000,1/FAK(J))-EXP(1) = -2@10 -2571
5000-stellige Genauigkeit, Restfehler durch endliche Summe
Summe über 1/N! alternierend 1 - 1/1! + 1/2! von 0 bis unendlich = 1/e
SUM(0,1000,(-1)^J/FAK(J))-1/EXP(1) = 2@10 -2571
5000-stellige Genauigkeit, Restfehler durch endliche Summe
1 - 1/2 + 1/3 - 1/4 ..... = ln 2
SUM(1,10000,-(-1)^J/J - LN(2) = -4.99975@10 -5.
Stimmt mit normalem Taschenrechner überein.
1 + 1/2 + 1/4 + 1/8 ..... = 2
SUM(0,1000,1/2^J) - 2 = -9.3@10 -302 und 0 mit oberer Summengrenze 10000.
1 + 1/2^4 + 1/3^4 + 1/4^4 ..... = B 4/90
SUM(1,10000,1/J^4) - PI^4/90 = -3.3@10 -13 und -2.7@10 -13 mit normalem Taschenrechner.
Test: Ausdrücke als untere und obere Grenze, Verwendung von SUM in komplexeren Ausdrücken
SUM(4-3,NINT(PI)+1,1/J) = 2.08333333
PI+SUM(4-3,NINT(PI)+1,1/J) = 5.224925
SUM(4-3,NINT(PI)+1,1/J)+SUM(4-3,NINT(PI)+1,1/J) = 4.16666666
TEFU(N,K)
Die Divisorfunktion TEFU(N,K) bestimmt alle positiven Teiler T von N und berechnet die Summe über alle
T^K. Für K = 0 wird dadurch die Zahl der Teiler festgestellt, d. h. man erhält das gleiche Ergebnis wie mit
TEZA(N). N und K sind ganzzahlig und im ganzen INTEGER*4-Bereich erlaubt, d. h. -2147483647 # N,K #
2147483647. N darf jedoch nicht Null betragen.
TEFU(1,K) = 1, da es nur den Teiler 1 gibt
TEFU(0,K):
Fehlermeldung
TEFU(-N,K) = TEFU(N,K), da die Teiler identisch sind
TEFU(10,0) = 4 = nämlich 1, 2, 5 und 10
TEFU(10,2) = 130 = 1^2 + 2^2 + 5^2 + 10^2
TEFU(10,-1) = 1.8 = 1/1 +1/ 2 + 1/5 + 1/10
TEFU für einige größere Argumente in Übereinstimmung mit Mathematica
TEFU(10000000,1) = 24902280
TEFU(10000000,-1) = 2.490228000000000
TEFU(350377,2)
= 122764042130
Sonderfall im Algorithmus: Primzahl > 46341
TEFU(3*350377,-1) = 1.333337138758156. . .
Sonderfall: Nach Division durch eine kleine
Primzahl verbleibt eine Primzahl > 46341
TEFU(2*3*5*7*11*350377,5) = 359793116835833326161219124948592665870803456
X*TEFU(X,-1)-TEFU(X,1) = 0
X^2*TEFU(X,-2)-TEFU(X,2) = 0
für verschiedene natürliche X; die “Null” in
Abhängigkeit von der Rechengenauigkeit
TEZA(N)
Gibt die Zahl der positiven Teiler von N aus. Zur Berechnung wird N in seine Primfaktoren zerlegt:
Die Teilerzahl ist dann:
N muss ganzzahlig und ABS(N) kleiner gleich 10^6 sein.
TEZA(17) = 2 (1,17)
TEZA(20) = TEZA(2^2*5^2) = (2+1)*(1+1) = 6 (1,2,4,5,10,20)
TEZA(1)
=1
TEZA(1000) = TEZA(2^3*5^3) = 4*4 = 16
TEZA(3^4*13^2*17^4) = (4+1)*(2+1)*(4+1) = 75
TEZA(-N) = TEZA(N)
TEZA(0) = 0, so gesetzt in Übereinstimmung mit der Ausgabe bei Mathematik/Mengen aus der Zahlentheorie
TEZA(10^11) = 144 in Übereinstimmung mit Mathematica
PTZA(N)
Gibt die Zahl der positiven Primteiler von N aus. Zur Berechnung wird N in seine Primfaktoren zerlegt und die
Zahl der unterschiedlichen Faktoren bestimmt.
N muss ganzzahlig und ABS(N) kleiner gleich 10^12 sein.
PTZA(1)
=0
PTZA(2)
= 1 (2)
PTZA(3)
= 1 (3)
PTZA(1000) = TEZA(2^3*5^3) = 2
PTZA(3^4*11^2*17^2) = 3
PTZA(-N) = PTZA(N)
PTZA(0)
=0
PTZA(3*2147483647) = 2
Sonderfall: Nach Division durch eine kleine Primzahl verbleibt eine
Primzahl > 1000000
PTZA(2147483647) = 1
Sonderfall im Algorithmus: Primzahl > 1000000