W.Ehrhardt: Sonstiges

Es ist seit mehr als 15 Jahren bekannt, daß exp bis zu 13 Bits für
extended Argumente verliert; selbst die neueren Delphi-Versionen
(bestätigt bis D14, einige sind korrigiert in D17) haben schlimme Bugs: z.B.
arccsch(2) = 0.27980789397 (korrekt = 0.48121182506);
coth(12000)=1 oder sech(12000)=0 stürzen ab,
sinh(x)/x=0 statt 1 für kleine x,
sin(1e22)=1e22 (korrekt = -0.852200849767);
StdDev(a,a+1,a+2) stürzt ab für a=100000000000; usw.

Die elementaren mathematischen Funktionen umfassen:
Exponential-, Logarithmus-, trigonometrische, hyperbolische, inverse
trigonometrische / hyperbolische Funktionen.
Weiter gibt es Polynom-, Vektor- und Statistikprozeduren,
sowie Fließkomma- und FPU-Kontrollfunktionen.

Delphis unsinnige Routinen
(IfThen, IsZero, InRange …) und seine Finanzfunktionen sind nicht
(und werden auch nicht) implementiert. Hier ist die vollständige Liste der
AMath-Funktionen mit kurzen Beschreibungen.

Alle elementaren transzendenten Standard-Funktionen mit einem Argument haben
maximale relative Fehler kleiner als 2.2e-19, die Werte für power(x,y)
sind 2.1e-19 (für |x|,|y| < 1000) und 3.4e-19 (für |x|,|y| < 2000).
Die Genauigkeit wird ermittelt mit dem Programm
t_amathx, das MPArith-Prozeduren benutzt.

Die double-extended ext2-Routinen arbeiten mit Paaren von
Extended-Gleitkommazahlen, die die nicht-ausgewertete Summe der höher- und niederwertigen Teile
repräsentieren a = (a.h, a.l) = a.h + a.l, normalerweise mit |a.l| ≤ eps_x*|a.h|.

Util

PRNG

MPArith

AMath

DAMath

zlib

Delphi CRT-Unit

• Base2N V0.42: Allgemeine Konvertierungen
  zur Basis 2**N, N=1…6
• Bitarray V0.19:
  Bit-Array-Context mit max. 524160 Bits (Nebenprodukt des MPArith-Siebs
  für 16-Bit-Primzahlen)
• BTypes V0.21:
  Gemeinsame portable Basis-Datentypen
• Compvers V0.39:
  Compiler-Version als String oder Symbol
• Dates V0.38:
  Implementiert Compiler- und Betriebssystem unabhängige Routinen für
  das aktuelle Datum und die aktuelle Zeit (incl. Millisekunden seit
  Mitternacht) und Funktionen für Julianische Tageszahlen.
• Hrtimer V0.29:
  Enthält einen hochauflösenden Zeitmesser für
  Pascal/Delphi-Compiler, es wird der comp Datentyp verwendet. Der Zeitmesser
  benutzt den RDTSC-Befehl, deshalb stoppt die Unit auf allen Systemen, die
  diesen Befehl nicht unterstützen (abschaltbar via $ifdef). HRTimer wird
  von einigen Optimierungs-Testprogrammen benötigt.
• memh V0.15:
  Implementiert portable Funktionen für sichere Speicherbelegung auf dem Heap.
• Mem_util V0.99:
  Implementiert Compiler-unabhängige Routinen zum Vergleich von
  Speicherblöcken und zur Darstellung von Speicherbereichen als HEX- und
  Base64-Strings.
• Ministat V0.45:
  Kleine Statistik-Unit mit akkuraten „laufende Statistik“-Routinen für
  eine und zwei Variable.
• Sort V1.18:
  Allgemeine QuickSort-, HeapSort- (Standard und Bottom-up), CombSort-Routinen,
  die swap/compare-Funktionen benutzen. Zusätzliche Pointerversionen haben
  einen typlosen Zeiger, der in den Routinen durchgeschleift wird und zum
  Zugriff auf lokale Daten usw. des Aufrufers verwendet werden kann.
• std.inc V1.71:
  Standard-Includedatei für Compiler­erkennung, Standard­definitionen, Optionen.
• Tsc V0.44:
  Diese Unit verwendet einen maschinennäheren Zugriff auf den TSC als
  hrtimer. Es wird außerdem ein systemabhängiger allgemeiner Zähler bereitgestellt
  (TSC falls vorhanden; sonst GetTickCount, 18.2 Hz Systick-Zähler oder Millisekunden seit
  Mitternacht).

• Bob Jenkins Public-Domain-Generator ISAAC
   (Indirection, Shift, Accumulate, Add, und Count).
  Die mittlere Periodenlänge wird mit 2**8295 angegeben, die minimale Länge ist 2**40.
• salsar basiert auf der Salsa20-
  Stromchiffre und benötigt die salsa20-Unit (enthalten in
  $supp_rng.zip) Die Basisroutine verwendet 128-Bit Schlüssel und 8 Runden
  (dieser Standardwert kann mit der Prozedur salsar_set_rounds auf 12
  oder 20 geändert werden).
• aesr benutzt AES/CTR-Modus-Routinen
  mit 128-Bit Schlüsseln (enthalten in $supp_rng.zip).

• Neue Funktionen:
  ASX-Simulation für 64-Bit, const PINC für
  standardmäßige Genauigkeitserhöhung
• Geänderte Funktionen:
  frexpx/ldxepx nur wenn nicht EXT64, prime32 benutzt Doubles,
  mpf_??_ext geändert nach mpf_??_dbl, mpc_??_ext geändert nach mpc_??_dbl,
  s_mp_ln/log2 liefern double
• Anderes:
  Einige manuelle Genauigkeitsanspassungen

• 
  AMath V2.44:

  Diese Unit implementiert akkurate elementare Funktionen;
  AMath stellt viele der Delphi-Math-Funktionen für die anderen unterstützten
  Pascalversionen zur Verfügung und beseitigt Fehler und Ungenauigkeiten von Delphi.

• 
  Die Unit AMTools V0.45 bietet akkurate und zuverlässige Werkzeuge zur
  Nullstellenbestimmung und Suche lokaler Minima von Funktionen, zur
  näherungsweisen Berechnung von eindimensionalen Integralen,
  zur Konvergenz-Beschleunigung von Folgen und Reihen,
  sowie zur Lösung quadratischer, kubischer und polynomialer Gleichungen:

  Die Funktionen localmin, mbrent, fmin (sie unterscheiden sich nur
  durch Anzahl der Parameter) verwenden Brents Algorithmus mit garantierter
  Konvergenz zur Bestimmung eines lokalen Minimums einer Funktion
  in einem Intervall (a,b). Der Algorithmus kombiniert Suche via
  Goldenem Schnitt und sukzessive parabolische Interpolation und benutzt
  nur Funktionsaufrufe (keine Ableitungen).

  Die Funktionen zbrent und zeroin benutzen den Brent/Dekker-Algorithmus
  mit garantierter Konvergenz zur Nullstellen-Berechnung einer stetigen Funktion
  in einem Intervall [a,b], wenn f(a) und f(b) verschiedene Vorzeichen haben;
  zbrenty findet Nullstellen von f(x)-y. Der Algorithmus basiert auf
  der Kombination von wiederholter Interpolation und Bisektion.

  Die qag*-Prozeduren sind Pascalübersetzungen der entsprechenden
  Quadpack
  -Algorithmen von R. Piessens, E. de Doncker-Kapenga, C.W. Überhuber, D. Kahaner.
  Diese global-adaptiven Routinen implementieren die numerische Integration
  von Funktionen über endlichen oder unendlichen Intervallen und arbeiten
  mit Gauss-Kronrod-Regeln für die Teilintervalle und Wynns Epsilon-Algorithmus
  zur Konvergenz-Beschleunigung. Sie können relativ schwierige Integrale
  berechnen, u.a. auch für Integranden mit Sprungstellen und integrierbaren
  Singularitäten. quagk ist eine einfache übergeordnete Prozedur, die die
  speziellen Routinen aufruft.
  Der Quadpack-Algorithmus qawc berechnet den Cauchyschen Hauptwert
  von f(x)/(x-c) mit einer global-adaptiven Strategie und modifizierter
  Clenshaw-Curtis-Integration auf den Teilintervallen, die den Punkt x=c enthalten.

  Die Prozeduren intdeo und intdei
  benutzen die doppelt-exponentielle (DE) Transformation (entwickelt von M. Mori, T. Ooura und anderen)
  zur automatischen Quadratur von f(x) über das halbunendliche Intervall (a,+INF)
  für Funktionen mit und ohne oszillatorische Faktoren.
  intde integriert über endliche Intervalle (a,b) und
  intde_p, intdei_p sind die entsprechenden Prozeduren für
  Funktionen f(x,p) mit Parametern.

  Der adaptive Quanc8-Algorithmus von G.E. Forsythe, M.A. Malcolm, C.B. Moler
  approximiert das Integral einer glatten Funktion über einem endlichen
  Intervall mit Hilfe einer Newton-Cotes-Regel.

  
  Die Prozeduren levinu1 und wynneps1 sind eigenständige
  Versionen von bereits verwendeten Methoden zur Konvergenz-Beschleunigung,
  sie führen jeweils einen Schritt der Levin u-Transformation für Summen
  oder eine Iteration des Wynnschen Epsilon-Algorithmus
  für Summen oder Folgen aus (spezialisierte Originalversionen
  werden in LerchPhi bzw. den Quadpack-Routinen eingesetzt).
  Der Konvergenz-Verlauf der Prozesse muß von den übergeordneten
  aufrufenden Routinen analysiert und überwacht werden.

  Die squad-Funktionen berechnen
  genaue Lösungen quadratischer Gleichungen mit Double-Koeffizienten,
  sie implementieren Ideen von G.E. Forsythe, W. Kahan, P.H. Sterbenz
  (hochgenaue Berechnung der Diskriminante, Skalierung mit Zweierpotenzen).
  
  Die cubsolve-Prozedur ermittelt die Lösungen reeller kubischer
  Gleichungen mit Double-Koeffizienten, sie beruht auf Vorlesungsnotizen von W. Kahan.
  
  Die Prozedur PolyRoots berechnet die n (komplexen) Nullstellen
  x[k] + i*y[k] des Polynom p[0] + p[1]*z + … p[n]*z^n
  mit dem QR-Algorithmus angewendet auf die ausgeglichene Begleitmatrix
  (balanced companion matrix). PolyRootsA benutzt PolyRoots,
  anschließend werden die Nullstellen sortiert und verbessert.

• 
  Die Units SpecFun/SpecFunX V1.51.07 implementieren viele spezielle
  Funktionen mit Double- und Extended-Genauigkeit. In dieser Ausgabe sind
  folgende Funktionsgruppen verfügbar:

  Zur Zeit gibt es für alle Funktionen Double- und Extended-Versionen
  (extended mit Suffix x, z.B. erfc vs. erfcx).
  Hier ist die vollständige Liste der
  Speziellen Funktionen
  mit kurzen Beschreibungen.
  Die Datei specialfunctions.pdf
  enthält das (englische) Referenzhandbuch Spezielle Funktionen mit Implementationshinweisen.

  Im allgemeinen haben die Extended-Versionen der Funktionen größere relative
  Fehler (gemessen in den entsprechenden relativen Rundungseinheiten eps_x bzw.
  eps_d) als ihre Double-Gegenstücke, insbesondere gammax und
  betax für große Argumente. Weiterhin ist zu beachten, daß
  einige Funktionen bei kleinen Argumentänderungen starke Änderungen
  bei den Funktionswerten zeigen; bei hochgenauen Vergleichen sollten deshalb
  nur Argumentwerte verwendet werden, die in beiden Rechnungen exakt darstellbar sind.

• 
  Die Unit AMCmplx V0.98 implementiert AMath-basierte komplexe Arithmetik
  sowie grundlegende und transzendente Funktionen;
  hier die komplette Liste
  mit kurzen Beschreibungen, im Referenz-PDF gibt es ein eigenes Kapitel.
  Der Datentyp complex ist ein Record mit
  Real- und Imaginärteil vom Typ extended. Die meisten Routinen sind Prozeduren
  mit const Eingabe-Record(s) und var Ausgabe;
  deshalb setzt die Unit BP7 oder neuere Compiler voraus.

  Bitte beachten: Die Exponential-, trigonometrischen und Hyperbel-Funktionen
  können Überlauf erzeugen oder INF bzw. NaN zurückliefern für Eingaben
  mit Real- oder Imaginärteil in der Nähe von ln_MaxExt oder größer,
  diese Situationen werden systematischer in kommenden Versionen behandelt.

• 
  Die Unit AMQuat V0.20 implementiert AMath-basierte
  Arithmetik sowie grundlegende und transzendente Funktionen für
  Quaternionen, hier die komplette Liste
  mit kurzen Beschreibungen.

  Der Datentyp quaternion ist ein Record mit
  Real- oder Skalarteil und Imaginär- oder Vektorteil:

  type
    Quaternion = record
                   r:     extended; {real or scalar part     }
                   x,y,z: extended; {imaginary or vector part}
                 end;
  

  Die meisten Routinen sind Prozeduren
  mit const Eingabe-Record(s) und var Ausgabe.
  Eine Quaternion wird oft geschrieben als a = r1 + xi + yj
  + zk, wobei 1, i, j, k die Basisquaternionen sind
  (als 4-dimensionale Vektoren sind sie die Standard-Einheitsvektoren).

  Addition und Subtraktion sind komponentenweise definiert,
  d.h. als übliche Vektoraddition in R⁴. Die Multiplikation
  von Quaternionen ist assoziativ und distributiv,
  aber sie ist nicht kommutativ, sondern festgelegt durch die Relationen
  i^2 = j^2 = k^2 = ijk = -1. Die Norm einer Quaternion
  ist r^2 + x^2 + y^2 +z^2, der Betrag |a| ist die Quadratwurzel der
  Norm und conj(a) = r1 – xi – yj – zk
  heißt Konjugierte. Die multiplikative Inverse ist (1/a) = conj(a)/norm(a)
  und die Division ist definiert als a/b = a*(1/b).

  Die meisten (inversen) trigonometrischen / hyperbolischen Quaternion-Funktionen
  b=f(a) werden in AMath im allgemeinen berechnet mit der korrespondieren
  komplexen Funktion w=F(z) mit z = Re(a) + i*abs(Im(a))
  und der Abbildung auf Quaternionen Re(b) = Re(w), Im(b) =
  Im(w)*Im(a)/abs(Im(a)).
  Zu beachten: Es gibt keine Potenzfunktion zweier Quaternionen a^b,
  für reelle b=x reell wird a^x definiert als exp(x*ln(a)).

• Bessel-Funktionen und verwandte,
• elliptische Integrale/Funktionen und Thetafunktionen,
• Exponentialintegrale und verwandte,
• Fehlerfunktion und verwandte,
• Gamma-Funktion und verwandte,
• Zetafunktionen, Polylogarithmen und verwandte,
• orthogonale Polynome, Legendrefunktionen und verwandte,
• hypergeometrische Funktionen und verwandte,
• statistische Verteilungen,
• und verschiedene spezielle Funktionen.

• 
  DAMath V1.12:
  Diese Unit implementiert akkurate elementare mathematische Funktionen mit
  Double-Genauigkeit: Exponential-, Logarithmus-, trigonometrische, hyperbolische, inverse
  trigonometrische / hyperbolische Funktionen; außerdem gibt es
  Polynom-, Vektor- und Statistikprozeduren und Fließkomma-Funktionen.

  Aus der System-Unit benutzt DAMath die Funktionen abs, arctan, frac, int, ln und trunc
  (einschließlich vorhandener Fehler in 32-Bit-Versionen).
  Weil FPC-64 (Versionen ≤ 2.6.4) bis zu 13 der 53 Bits für die Exponentialfunktion verliert,
  implementiert DAMath eine eigene exp-Funktion. System.sin(x)
  und cos(x) werden für |x| ≤ Pi/4 benutzt, für |x| > 2^30 wird die
  Bereichsreduktion nach Payne/Hanek verwendet.

  Unter Win7/64 haben die DAMath-64-Bit-Versionen der elementaren transzendenten
  Standardfunktionen mit einem Argument und die Potenzfunktion maximale relative
  Fehler kleiner als 2*eps_d (ca. 4.4e-16), die RMS-Werte sind < 0.6*eps_d;
  die vollständige Liste und die entsprechenden Zahlen für Delphi/FPC
  findet man in der Datei t_xdamat64.cmp.

  Die double-double dbl2-Routinen rechnen mit Paaren von 53-Bit-Zahlen, die die
  nicht-ausgewertete Summe repräsentieren a = (a.h, a.l) = a.h + a.l,
  normalerweise mit |a.l| ≤ eps_d*|a.h|.

• 
  Die Unit DAMTools V0.46 bietet akkurate und zuverlässige Werkzeuge zur
  Nullstellenbestimmung und Suche lokaler Minima von Funktionen, zur
  näherungsweisen Berechnung von eindimensionalen Integralen,
  zur Konvergenz-Beschleunigung von Folgen und Reihen,
  sowie zur Lösung quadratischer, kubischer und polynomialer Gleichungen.

• Die auf DAMath basierenden Speziellen Funktionen mit Doubleprecision
  sind aus den AMath-Implementationen abgeleitet, d.h. die
  Beschreibungen in der Einführung
  und im Referenzmanual specialfunctions.pdf
  sind (mit offensichtlichen Einschränkungen) im wesentlichen gültig,
  die Funktionen der Interface-Unit SpecFunD V1.36.08
  haben die gleichen Namen usw. Hier einige interne Details:

• 
  Die Unit DAMCmplx V0.57 implementiert DAMath-basierte komplexe Arithmetik
  sowie grundlegende und transzendente Funktionen; der Datentyp
  complex ist ein Record mit Real- und Imaginärteil vom Typ double.

• 
  Die Unit DAMQuat V0.20 implementiert DAMath-basierte
  Arithmetik sowie grundlegende und transzendente Funktionen für
  Quaternionen.

  Der Datentyp quaternion ist ein Record mit
  Real- oder Skalarteil und Imaginär- oder Vektorteil:

  type
    Quaternion = record
                   r:     double; {real or scalar part     }
                   x,y,z: double; {imaginary or vector part}
                 end;
  

  Die meisten Routinen sind Prozeduren
  mit const Eingabe-Record(s) und var Ausgabe.
  Addition und Subtraktion sind komponentenweise definiert. Die Multiplikation
  von Quaternionen ist assoziativ und distributiv,
  aber sie ist nicht kommutativ. Die meisten (inversen) trigonometrischen / hyperbolischen Quaternion-Funktionen
  werden im allgemeinen mit der korrespondieren komplexen Funktion berechnet.

• Die internen Funktionen haben den Prefix sfd_, die Unitnamen
  beginnen mit sd, z.B. sdBessel vs. sfBessel.
• Konstanten, Argument- und Funktionswert-Bereiche wurden an Doubleprecision
  angepaßt.
• Hex/Extended-Konstrukte wurden durch Hex/Double ersetzt (teilweise neuberechnet).
• Die meisten Approximationen mit Polynomen oder rationalen Funktionen wurden
  beibehalten, sie sind deshalb manchmal sub-optimal (optimale Doubleprecision-Approximationen
  sind in der Regel sehr verschieden).
• Chebyshev-Approximationen konnten einfach an Doubleprecision angepaßt werden!
• Der relative Fehler der Speziellen Funktionen aus DAMath ist normalerweise
  größer (besonders auf 64-Bit-Systemen) als der der entsprechenden AMath
  Double-Funktionen (die oft wegen der internen Extended-Arithmetik korrekt
  gerundet sind).
  

• Die Code-Basis V1.1.4 ist sehr alt und es gibt inzwischen neuere und
  bessere Zlib-Versionen. Deshalb sollten neuere Delphi- und FPC-Versionen
  soweit möglich die mitgelieferten Zlib-Units verwenden.
• Meine zlib-Routinen sollten nur auf Dateien mit weniger als 2 GB angewendet
  werden (32 Bitzähler; Delphi eof-Fehler und/oder 32-Bit filesize Funktion).

© 2018 W.Ehrhardt

Letzte Änderung 08. Okt. 2018

Start

CRC/Hash

Krypto

Sonstiges

Info

Links

English

Sonstiges

			BP7	BP7	D6	D6	D18/64	D18/64
Generator	ctx Größe	Periode ca.	C/B	MB/s	C/B	MB/s	C/B	MB/s
pasrand	4	2**32	74.0	22.9	5.0	294.0	5.0	459.0
taus88	16	2**88	79.0	21.5	8.0	211.9	10.8	213.5
taus113	20	2**113	85.0	20.0	8.0	211.9	13.5	170.0
kiss123	20	2**123	114.0	14.9	13.3	127.9	15.0	153.0
tt800	106	2**800	308.3	5.5	18.5	91.7	18.0	126.7
well1024a	134	2**1024	166.5	10.2	7.8	218.7	13.8	166.9
xor4096	522	2**4096	80.0	21.0	6.5	260.7	12.3	187.3
mt19937	2502	2**19937	227.4	7.4	8.3	204.5	12.6	181.5
aesr	290	2**128	211.2	8.0	28.4	59.7	60.2	38.1
salsar	202	2**70	108.3	15.7	15.4	110.3	31.1	73.8
isaac	2066	2**8295	122.0	13.9	9.0	189.3	12.8	178.9

Start

CRC/Hash

Krypto

Sonstiges

Info

Links

English

procedure generic_init(var ctx: generic_ctx; seed: longint);
  {-Init context from seed}

procedure generic_init0(var ctx: generic_ctx);
  {-Init context from randseed}

procedure generic_next(var ctx: generic_ctx);
  {-Next step of PRNG}

procedure generic_read(var ctx: generic_ctx; dest: pointer; len: longint);
  {-Read len bytes from the PRNG to dest}

function  generic_long(var ctx: generic_ctx): longint;
  {-Next random positive longint}

function  generic_dword(var ctx: generic_ctx): {$ifdef HAS_CARD32}cardinal{$else}longint{$endif};
  {-Next 32 bit random dword (cardinal or longint)}

function  generic_word(var ctx: generic_ctx): word;
  {-Next random word}

function  generic_double(var ctx: generic_ctx): double;
  {-Next random double [0..1) with 32 bit precision}

function  generic_double53(var ctx: generic_ctx): double;
  {-Next random double in [0..1) with 53 bit precision}

function  generic_rangew(var ctx: generic_ctx; range: word): word;
  {-Next random word in range 0..range-1}

function  generic_rangel(var ctx: generic_ctx; range: longint): longint;
  {-Next random longint in range 0..range-1}

function  generic_selftest: boolean;
  {-Simple self-test of PRNG}

std.zipstd.incBTypesVor dem Herunterladen von Software von diesen Seiten bitte diesen
rechtlichen Hinweis beachten.Letzte Änderungen:Letzte Änderungen: Well1024arangel/wtaus88taus113tt800mt19937kiss123 well1024axor4096kryptographischeMultipräzisions-Arithmetik für ganze, rationale,
reelle und komplexe ZahlenLetzte Änderungen:akkurate mathematische MethodenrmNearest80-Bit-ExtendedkeineLetzte Änderungen:AMathSpezielle FunktionenAMCmplxakkurate mathematische MethodenDoubleDFPUAMathLetzte Änderungen:DAMathSpezielle FunktionenDAMCmplxPASZLIB 1.0zlibexzpipeLetzte Änderungen: zlibzlibhgzioBitte beachten:Letzte Änderungen: nichtAusschlußhinweisHinweis:nichtrandomministat-hrtimer-{$define testing}constFeaturesconstderuses-‚unit was based heavily
off of the Borland CBuilder 5 RTL‘readkeykeypressed
UtilPRNGMPArithAMathDAMathzlibDelphi CRTutil_2018-10-08.zipprng_2018-01-01.zipmparith_2018-08-08.zipEinführungsseite FunktionslisteReferenzabschnittamath_2018-10-08.zipDAMath-Einführungsseitedamath_2018-10-08.zipzlibw114_2015-09-14.zipzlibFZCA-DemoprogrammMPArithdcrt_2017-11-29.zipLinks