Util

• Base2N V0.41: General base 2**N conversion routines (N=1...6)
• Bitarray V0.18: Bit array context with max. 524160 bits (spin off from MPArith 16 bit prime sieve)
• Compvers V0.26: Compiler version as string or symbol
• Dates V0.35: Implements compiler and OS independent routines for the current date and time (including milliseconds since midnight) and functions for Julian day numbers.
• Hrtimer V0.28: Contains a high resolution timer for most Pascal/Delphi compilers using the comp data type. It uses the RDTSC instruction, therefore it will stop on machines that do not support RDTSC (this feature can be turned off via $ifdef). The timer is used by several optimizing test programs.
• Mem_util V0.99: Implements compiler independent routines for comparing memory blocks and converting memory blocks to HEX and Base64 strings.
• Ministat V0.45: Statistics unit with accurate "on the fly" statistics routines for one and two variables.
• Sort V1.18: General QuickSort, HeapSort (standard and bottom-up), CombSort routines using swap/compare functions. Additional pointer versions have a typeless data pointer that is carried through the functions and can be used to access local data etc by the caller.
• Tsc V0.40: This unit has a more low level access to the Time Stamp Counter than hrtimer and additionally defines a system dependent low resolution counter (GetTickCount, 18.2 Hz Systick, or milliseconds since midnight) if RDTSC support is not available.

PRNG

• Bob Jenkins' public domain ISAAC random number generator (Indirection, Shift, Accumulate, Add, and Count). The average cycle length of ISAAC is 2**8295, the minimum length is 2**40.
• salsar is based upon the Salsa20 stream cipher and needs the salsa20 unit from salsa_YYYY-MM-DD.zip. The core routine uses 128 bit keys and 8 rounds (this default value can be changed to 12 or 20 rounds with salsar_set_rounds).
• aesr uses CTR mode routines from aes_YYYY-MM-DD.zip with 128 bit keys.

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: xor4096_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_selftest: boolean;
  {-Simple self-test of PRNG}

MPArith

• New functions: mpf_vers in mp_real
• Changed functions: Improved mpf_todouble and mpf_toextended
• Other: DH command in t_rcalc
• Bugfixes: sqrtmod and cbrtmod in mp_calc, if v2 = prime^1

AMath

• AMath V1.70: This unit implements accurate mathematical functions; it makes many routines of Delphi's math unit available to other supported Pascal versions and fixes bugs and inaccuracies of Delphi:

  It is known since more than 15 years that exp looses up to 13 bits for extended arguments; even the newer Delphi versions (confirmed up to D14, some are corrected in D17) have horrible bugs: e.g. arccsch(2) = 0.27980789397 (correct = 0.48121182506); coth(12000)=1 crashes; sech(12000)=0 crashes; sinh(x)/x=0 for small x; sin(1e22)=1e22 (correct = -0.852200849767); StdDev(a,a+1,a+2) crashes e.g. for a=100000000000; etc..

  AMath's elementary mathematical functions include: exponential, logarithmic, trigonometric, hyperbolic, inverse circular / hyperbolic functions. There are polynomial, vector, statistic operations as well as floating point and FPU control functions. Delphi's nonsense routines (IfThen, IsZero, InRange ...) and its financial functions are not (and will not be) implemented. Here is the complete list of AMath functions with short descriptions.
  
  All standard one argument elementary transcendental functions have peak relative errors less than 2.2e-19, values for power(x,y) are 2.1e-19 (for |x|,|y| < 1000) and 3.4e-19 (for |x|,|y| < 2000). The precision is tested with the t_amathx program using MPArith functions.
  
  

• The AMTools unit provides accurate and reliable tools for finding zeroes and local minima of functions, numerical integration of one-dimensional functions, and solving quadratic equations:
  
  The functions localmin, mbrent, and fmin (differing in parameter count / ease of use) use Brent's algorithm with guaranteed convergence for finding a local minimum of a function f in an interval (a,b). The algorithm combines golden section search and successive parabolic interpolation using only function (not derivative) evaluations. The functions zbrent and zeroin use the Brent/Dekker algorithm with guaranteed convergence for finding a zero of a continuous function f in the interval [a,b], when f(a) and f(b) have different signs. The algorithm is based on a combination of successive interpolations and bisection.
  
  The qag* procedures are Pascal translations of Quadpack algorithms by R. Piessens, E. de Doncker-Kapenga, C.W. Überhuber, D. Kahaner. These routines perform global adaptive quadrature of functions over finite or infinite intervals based on Gauss-Kronrod rules for the subintervals and acceleration by Wynn's epsilon algorithm, they can handle rather difficult integrals including integrand functions with local difficulties such as a discontinuities and integrable singularities. quagk is a simple general purpose shell for the qag* routines. The Quadpack algorithm qawc computes the Cauchy principal value of f(x)/(x-c) using a globally adaptive strategy and modified Clenshaw-Curtis integration on the subintervals containing the point x=c.
  
  The procedures intdeo and intdei use the Double Exponential (DE) transformation (developed by M. Mori, T. Ooura, and others) for automatic quadrature of f(x) over the infinite interval (a,+INF) for functions with and without oscillatory factors resp. The DE transformation is very powerful if the abscissas a+x_i can be processed with high accuracy; therefore the two routines are best used with a=0, otherwise there can be severe roundoff problems (a+x_i=a).
  
  The adaptive quanc8 algorithm by G.E. Forsythe, M.A. Malcolm, C.B. Moler estimates the integral of a smooth function over a finite interval using a Newton-Cotes rule.
  
  The squad functions accurately solve quadratic equations with double coefficients; they implement ideas of G.E. Forsythe, W. Kahan, P.H. Sterbenz (high precision calculation of discriminant, scaling by powers of two etc).
  
  
• The units SpecFun/SpecFunX V1.18.19 implement many special functions for double and extended precision. In this release the following function groups are available:
  • Bessel functions and related,
  • elliptic integrals/functions and theta functions,
  • gamma function and related,
  • zeta functions and polylogarithms,
  • error function and related,
  • exponential integrals and related,
  • orthogonal polynomials, Legendre functions and related,
  • hypergeometric functions,
  • statistical distributions,
  • and other special functions.
  Currently all functions have double and extended versions (with name suffix x), e.g. erfc vs. erfcx, here is the complete list of AMath special functions with short descriptions. The file specialfunctions.pdf contains the Special Functions Reference Manual with Implementation Notes.
  
  Generally the extended versions have larger relative errors (measured in corresponding machine epsilon units eps_x or eps_d) than their double counterparts, especially gammax and betax for large arguments. Note that some functions are sensitive to small changes in the argument; therefore in high precision comparisons argument values should be used, that are representable in both calculations.

DAMath

• DAMath V0.47: This unit implements the double precision accurate mathematical functions: exponential, logarithmic, trigonometric, hyperbolic, inverse circular / hyperbolic functions; and there are the polynomial, vector, statistic operations and floating point functions.
  
  DAMath uses the system functions abs, arctan, frac, int, ln, and trunc (including possible bugs for 32-bit). Because FPC-64 looses up to 13 of the 53 bits for exp, DAMath implements its own exp function. System sin(x) and cos(x) are used for |x| ≤ Pi/4, Payne/Hanek range reduction is performed if |x| > 2^30.
  
  On Win7/64 the 64-bit DAMath one argument elementary transcendental functions and power have peak relative errors < 2*eps_d (about 4.4e-16), the RMS values are < 0.6*eps_d, a complete list and the Delphi/FPC figures can be found in the log files t_xdamat64.*.
  
  
• The DAMTools unit provides accurate and reliable tools for finding zeroes and local minima of functions, numerical integration of one-dimensional functions, and solving quadratic equations.
  
  
• DAMath based double precision special functions are derived from the AMath implementations, i.e. the descriptions in the introduction and the specialfunctions.pdf manual are essentially valid (with obvious restrictions), the interfaced functions in unit SpecFunD V1.03.05 have the same names, etc. Here are some internal details:
  • The internal functions are pre-fixed with sfd_, the unit names start with sd, e.g. sdBessel vs. sfBessel.
  • Constants, arguments, and function value ranges are adjusted to the double precision target.
  • Hex/extended constructs are replaced by hex/double (partly recalculated).
  • Most polynomial and rational approximations are kept, resulting in slightly sub-optimal implementations (optimal double precision approximations are usually very different).
  • Chebyshev approximations are easily adjusted to double precision!
  • The relative errors of the DAMath special functions are usually larger (especially on 64-bit systems) than those of the corresponding AMath double functions (which are often correctly rounded due to the internal extended precision calculations).

zlib

Delphi CRT unit