mpmath 0.3__zip → 0.4__zip

{mpmath-0.3 → mpmath-0.4}/CHANGES

@@ -1,3 +1,18 @@
+--0.4--
+Released November 3, 2007
+
+* new string conversion code (much faster; unlimited exponents)
+* fixed bug in factorial (it gave the wrong value, though gamma worked)
+* division now uses a rigorous algorithm for directed rounding
+  (mpmath previously used a heuristic that got the last bit wrong
+  in 1/10000 of cases)
+* misc. performance improvements (arithmetic is 15% faster)
+* refactored parts of the code; added many more docstrings and tests
+* added a function rand() for generating full-precision random numbers
+* rewrote the benchmark script to compare against Decimal and to
+  automatically generate timings with psyco both disabled and enabled
+* rewrote unit tests to use py.test
+
 --0.3--
 Released October 5, 2007
 

{mpmath-0.3 → mpmath-0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: mpmath
-Version: 0.3
+Version: 0.4
 Summary: Python library for arbitrary-precision floating-point arithmetic
 Home-page: http://mpmath.googlecode.com
 Author: Fredrik Johansson

{mpmath-0.3 → mpmath-0.4}/README

@@ -12,6 +12,7 @@ LICENSE file for details)
 0. History
 ----------
 
+* Version 0.4 released on November 3, 2007
 * Version 0.3 released on October 5, 2007
 * Version 0.2 released on October 2, 2007
 * Version 0.1 released on September 27, 2007
@@ -40,6 +41,9 @@ http://mpmath.googlecode.com/svn/trunk/
 2. Documentation and usage
 --------------------------
 
+Note: some additional documentation is available on the mpmath website.
+The unit tests and internal docstrings may also be helpful.
+
 Import mpmath with
 
     from mpmath import *
@@ -51,7 +55,7 @@ Python's float and complex types:
     mpf('0.66666666666666663')
 
     >>> mpc(0, -1)
-    mpc(real='0', imag='-1')
+    mpc(real='0.0', imag='-1.0')
 
     >>> mpf(-0.6) ** mpf(-0.2)
     mpc(real='0.89603999408558288', imag='-0.65101116249684809')
@@ -158,15 +162,12 @@ and verifies a 15-digit approximation interval for pi:
   singularities, and/or with the precision set to (say) several hundred
   digits, the last few digits in a result may be wrong.
 
-* Directed rounding works for addition and multiplication. It is implemented
+* Directed rounding works for arithmetic operations. It is implemented
   heuristically for other operations, and their results may be off by one
   or two bits in the last place (if otherwise accurate).
 
-* binary <-> decimal conversion currently uses the decimal module, which
-  is very slow and fails for extremely large and small numbers
-
 * Some IEEE 754 features such as infinities, NaN and denormal rounding
-  are not implemented
+  are not supported
 
 
 4. Help and bug reports

{mpmath-0.3 → mpmath-0.4}/demo/pidigits.py

@@ -1,9 +1,9 @@
 import sys
 import math
 from time import clock
-from mpmath import mpf
-from mpmath.lib import _pi_agm, small_numeral, normalize, bin_to_radix, \
-    fixed_to_str, ROUND_FLOOR
+
+from mpmath.lib import pi_agm, bin_to_radix, numeral
+
 
 def display_fraction(digits, skip=0, colwidth=10, columns=5):
     perline = colwidth * columns
@@ -25,27 +25,21 @@ def display_fraction(digits, skip=0, colwidth=10, columns=5):
             buf = buf[colwidth:]
         print s + ":", printed + colwidth*columns
 
-def calculateit(approx, func, base, n, tofile):
-
-    intpart = small_numeral(int(approx), base)
-    if intpart == "0":
-        skip = 0
-    else:
-        skip = len(intpart)
+def calculateit(base, n, tofile):
+    intpart = numeral(3, base)
+    skip = 1
 
     prec = int(n*math.log(base,2))+10
-    mpf.prec = prec
 
     print "Step 1 of 2: calculating binary value..."
     t = clock()
-    a = func(prec=prec, verbose=True, verbose_base=base)
-    a = mpf(normalize(a, -prec, prec, ROUND_FLOOR))
+    a = pi_agm(prec, verbose=True, verbose_base=base)
     step1_time = clock() - t
 
     print "Step 2 of 2: converting to specified base..."
     t = clock()
-    d = bin_to_radix(a.man, -a.exp, base, n)
-    d = fixed_to_str(d, base, n)
+    d = bin_to_radix(a, prec, base, n)
+    d = numeral(d, base, n)
     step2_time = clock() - t
 
     print "\nWriting output...\n"
@@ -70,7 +64,7 @@ def interactive():
     if tofile:
         tofile = open(tofile, "w")
 
-    calculateit(3.14, _pi_agm, base, digits, tofile)
+    calculateit(base, digits, tofile)
     raw_input("\nPress enter to close this script.")
 
 interactive()

{mpmath-0.3 → mpmath-0.4}/mpmath/functions2.py

@@ -178,15 +178,16 @@ def gamma(x):
     else:
         x -= 1
         prec, a, c = _get_spouge_coefficients(mpf.prec + 8)
-        if isinstance(x, mpf) and x == int(x):
-            xs = int(x)
+        # TODO: figure out when we can just use Stirling's formula
+        if isinstance(x, mpf) and x.exp >= 0:
+            s = _spouge_sum(x.man << x.exp, prec, a, c)
         else:
-            xs = x
-        s = _spouge_sum(xs, prec, a, c)
+            s = _spouge_sum(x, prec, a, c)
         # TODO: higher precision may be needed here when the precision
         # and/or size of x are extremely large
+        xpa = x + a
         mpf.prec += 10
-        g = exp(log(x+a)*(x+0.5)) * exp(-x-a) * s
+        g = exp(log(xpa) * (x + 0.5) - xpa) * s
 
     mpf.prec = oldprec
     return +g
@@ -196,7 +197,7 @@ def factorial(x):
     """Returns the factorial of x, defined in terms of the gamma
     function for non-integer x. An exception is raised if x is a
     negative integer."""
-    return gamma(x-1)
+    return gamma(x+1)
 
 
 #---------------------------------------------------------------------------#

mpmath-0.4/mpmath/lib/__init__.py

@@ -0,0 +1,7 @@
+from util import *
+from convert import *
+from floatop import *
+from squareroot import *
+from constants import *
+from functions import *
+from complexop import *

mpmath-0.4/mpmath/lib/complexop.py

@@ -0,0 +1,181 @@
+"""
+Arithmetic operations and functions on complex numbers, represented on
+rectangular form as tuples of real floating-point numbers.
+
+This module is quite compact, since most of the dirty work can be
+delegated to functions that work on real numbers.
+"""
+
+from util import *
+from floatop import *
+from functions import *
+from squareroot import *
+
+
+# Use fastest rounding mode for intermediate calculations
+RF = ROUND_FLOOR
+
+
+#----------------------------------------------------------------------
+# Complex parts
+#
+
+def fcabs(a, b, prec, rounding):
+    """
+    Absolute value of a complex number, |a+bi|. Returns a single
+    real number.
+    """
+    return fhypot(a, b, prec, rounding)
+
+
+#----------------------------------------------------------------------
+# Arithmetic
+#
+
+def fcmul(a, b, c, d, prec, rounding):
+    """
+    Complex multiplication.
+
+    Returns the real and imaginary part of (a+bi)*(c+di), rounded to
+    the specified precision. The rounding mode applies to the real and
+    imaginary parts separately.
+
+    Implemented the straightforward way. TODO: use a more stable
+    algorithm to avoid cancellation.
+    """
+
+    # All-real case
+    if b == d == fzero:
+        return fmul(a, c, prec, rounding), fzero
+
+    ep = prec + 10
+
+    re = fsub(fmul(a,c, ep, RF), fmul(b,d, ep, RF), prec, rounding)
+    im = fadd(fmul(a,d, ep, RF), fmul(b,c, ep, RF), prec, rounding)
+    return re, im
+
+
+#----------------------------------------------------------------------
+# Square root
+#
+
+def fcsqrt(a, b, prec, rounding):
+    """
+    Complex square root (principal branch).
+
+    We have sqrt(a+bi) = sqrt((r+a)/2) + b/sqrt(2*(r+a))*i where
+    r = abs(a+bi), when a+bi is not a negative real number.
+    """
+
+    if a == b == fzero:
+        return (a, b)
+
+    # When a+bi is a negative real number, we get a real sqrt times i
+    if a[0] < 0 and b == fzero:
+        im = fsqrt(fneg_exact(a), prec, rounding)
+        return (fzero, im)
+
+    ep = prec+20
+
+    t  = fadd(fcabs(a, b, ep, RF), a, ep, RF)  # t = abs(a+bi) + a
+    u  = fmul(t, fhalf, ep, RF)                # u = t / 2
+    re = fsqrt(u, prec, rounding)              # re = sqrt(u)
+    v  = fmul(t, ftwo, ep, RF)                 # v = t * 2
+    w  = fsqrt(v, ep, RF)                      # w = sqrt(v)
+    im = fdiv(b, w, prec, rounding)            # im = b / w
+
+    return re, im
+
+
+#----------------------------------------------------------------------
+# Exp and log
+#
+
+def fcexp(a, b, prec, rounding):
+    """
+    Complex exponential function.
+
+    We use the direct formula exp(a+bi) = exp(a) * (cos(b) + sin(b)*i)
+    for the computation. This formula is very nice because it is
+    perfectly stable; since we just do real multiplications, the only
+    numerical errors that can creep in are single-ulp rounding errors.
+
+    The formula is efficient since mpmath's real exp is quite fast and
+    since we can compute cos and sin simultaneously.
+
+    It is no problem if a and b are large; if the implementations of
+    exp/cos/sin are accurate and efficient for all real numbers, then
+    so is this function for all complex numbers.
+    """
+
+    mag = fexp(a, prec+4, rounding)
+
+    c, s = cos_sin(b, prec+4, rounding)
+
+    re = fmul(mag, c, prec, rounding)
+    im = fmul(mag, s, prec, rounding)
+    return re, im
+
+# TODO: log
+
+
+#----------------------------------------------------------------------
+# Trigonometric functions
+#
+
+def fccos(a, b, prec, rounding):
+    """
+    Complex cosine.
+
+    The formula used is cos(a+bi) = cos(a)*cosh(b) - sin(a)*sinh(b)*i.
+
+    The same comments apply as for the complex exp: only real
+    multiplications are performed, so no cancellation errors are
+    possible. The formula is also efficient since we can compute both
+    pairs (cos, sin) and (cosh, sinh) in single steps.
+    """
+    ep = prec + 6
+
+    c, s = cos_sin(a, ep, RF)
+    ch, sh = cosh_sinh(b, ep, RF)
+
+    re = fmul(c, ch, prec, rounding)
+    im = fmul(s, sh, prec, rounding)
+
+    return re, fneg_exact(im)
+
+
+def fcsin(a, b, prec, rounding):
+    """
+    Complex sine.
+
+    We have sin(a+bi) = sin(a)*cosh(b) + cos(a)*sinh(b)*i.
+    See the docstring for fccos for additional comments.
+    """
+    ep = prec + 6
+
+    c, s = cos_sin(a, ep, RF)
+    ch, sh = cosh_sinh(b, ep, RF)
+
+    re = fmul(s, ch, prec, rounding)
+    im = fmul(c, sh, prec, rounding)
+
+    return re, im
+
+
+# TODO: complex tan
+
+
+#----------------------------------------------------------------------
+# Hyperbolic functions
+#
+
+def fccosh(a, b, prec, rounding):
+    """Complex hyperbolic cosine. Computed as cosh(z) = cos(z*i)."""
+    return fccos(b, fneg_exact(a), prec, rounding)
+
+
+def fcsinh(a, b, prec, rounding):
+    """Complex hyperbolic sine. Computed as sinh(z) = -i*sin(z*i)."""
+    b, a = fcsin(b, a, prec, rounding)
+    return a, b

mpmath-0.4/mpmath/lib/constants.py

@@ -0,0 +1,212 @@
+"""
+Mathematical constants
+
+"""
+
+import math
+
+from util import *
+from floatop import *
+from squareroot import *
+
+
+def constant_memo(f):
+    """
+    Memoization for calculation of constants using fixed-point
+    arithmetic. Only store the value computed with highest precision;
+    if a lower or equal precision is requested later, the result can
+    be generated directly through downshifting the cached value.
+    """
+    f.memo_prec = -1
+    f.memo_val = None
+
+    def g(prec):
+        if prec == f.memo_prec:
+            return f.memo_val
+        if prec < f.memo_prec:
+            return f.memo_val >> (f.memo_prec-prec)
+        f.memo_val = f(prec)
+        f.memo_prec = prec
+        return f.memo_val
+
+    g.__name__ = f.__name__
+    g.__doc__ = f.__doc__
+    return g
+
+def acot(n, prec, hyperbolic):
+    """
+    Compute acot of an integer using fixed-point arithmetic. With
+    hyperbolic=True, compute acoth. We use the series expansion
+
+                   1        1        1
+        acot(n) = ---  -  ----  +  ----  -  ...,
+                            3         5
+                   n      3 n      5 n
+
+    optimized for integer arguments. In the hyperbolic case, all
+    negative terms are changed to positive ones.
+    """
+    s = t = (1 << prec) // n  # 1 / n
+    k = 3
+    while 1:
+        # Repeatedly divide by k * n**2, and add
+        t //= (n*n)
+        term = t // k
+        if not term:
+            break
+        # Alternate signs
+        if hyperbolic or not k & 2:
+            s += term
+        else:
+            s -= term
+        k += 2
+    return s
+
+def machin(coefs, prec, hyperbolic=False):
+    """
+    Evaluate a Machin-like formula, i.e., a linear combination of
+    acot(n) or acoth(n) for specific integer values of n, using fixed-
+    point arithmetic.
+
+    The input should be a list [(c, n), ...], giving c*acot[h](n) + ...
+    """
+    extraprec = 10
+    s = 0
+    for a, b in coefs:
+        s += a * acot(b, prec+extraprec, hyperbolic)
+    return (s >> extraprec)
+
+def agm_status(prec, step, adiff, verbose_base):
+    logdiff = math.log(max(1, adiff), verbose_base)
+    digits = int(prec/math.log(verbose_base,2) - logdiff)
+    print "  iteration", step, ("(accuracy ~= %i base-%i digits)" % \
+       (digits, verbose_base))
+
+def pi_agm(prec, verbose=False, verbose_base=10):
+    """
+    Compute floor(pi * 2**prec) as a big integer using the Brent-
+    Salamin algorithm based on the arithmetic-geometric mean.
+
+    See for example Wikipedia (http://en.wikipedia.org/wiki/Brent-
+    Salamin_algorithm) or "Pi and the AGM" by Jonathan and Peter
+    Borwein (Wiley, 1987). The algorithm (as stated in the Wikipedia
+    article) consists of setting
+
+      a_0 = 1
+      b_0 = 1/sqrt(2)
+      t_0 = 1/4
+      p_0 = 1
+
+    and computing
+
+      a_{n+1} = (a_n + b_n)/2
+      b_{n+1} = sqrt(a_n * b_n)
+      t_{n+1} = t_n - p_n*(a_n - a_{n+1})**2
+      p_{n+1} = 2*p_n
+
+    for n = 0, 1, 2, 3, ..., after which the approximation is given by
+    pi ~= (a_n + b_n)**2 / (4*t_n). Each step roughly doubles the
+    number of correct digits.
+    """
+    extraprec = 50
+    prec += extraprec
+
+    # Initialial values. a, b and t are fixed-point numbers
+    a = 1 << prec
+    b = sqrt_fixed2(a >> 1, prec)
+    t = a >> 2
+    p = 1
+
+    step = 1
+    while 1:
+        an = (a + b) >> 1
+        adiff = a - an
+        if verbose:
+            agm_status(prec, step, adiff, verbose_base)
+        # No change in a
+        if p > 16 and abs(adiff) < 1000:
+            break
+        prod = (a * b) >> prec
+        b = sqrt_fixed2(prod, prec)
+        t = t - p*((adiff**2) >> prec)
+        p = 2*p
+        a = an
+        step += 1
+    if verbose:
+        print "  final division"
+    pi = ((((a+b)**2) >> 2) // t)
+    return pi >> extraprec
+
+@constant_memo
+def pi_fixed(prec):
+    """
+    Compute floor(pi * 2**prec) as a big integer.
+
+    For low precisions, Machin's formula pi = 16*acot(5)-4*acot(239)
+    is used. For high precisions, the more efficient arithmetic-
+    geometric mean iteration is used.
+    """
+    if prec < 10000:
+        return machin([(16, 5), (-4, 239)], prec)
+    else:
+        return pi_agm(prec)
+
+def fpi(prec, rounding):
+    """Compute a floating-point approximation of pi"""
+    return normalize(pi_fixed(prec+5), -prec-5, prec, rounding)
+
+
+# Logarithms of integers can be computed easily using
+# Machin-like formulas
+
+@constant_memo
+def log2_fixed(prec):
+    return machin([(18, 26), (-2, 4801), (8, 8749)], prec, True)
+
+def flog2(prec, rounding):
+    return normalize(log2_fixed(prec+5), -prec-5, prec, rounding)
+
+
+@constant_memo
+def log10_fixed(prec):
+    return machin([(46, 31), (34, 49), (20, 161)], prec, True)
+
+def flog10(prec, rounding):
+    return normalize(log10_fixed(prec+5), -prec-5, prec, rounding)
+
+
+"""
+Euler's constant (gamma) is computed using the Brent-McMillan formula,
+gamma ~= A(n)/B(n) - log(n), where
+
+  A(n) = sum_{k=0,1,2,...} (n**k / k!)**2 * H(k)
+  B(n) = sum_{k=0,1,2,...} (n**k / k!)**2
+  H(k) = 1 + 1/2 + 1/3 + ... + 1/k
+
+The error is bounded by O(exp(-4n)). Choosing n to be a power
+of two, 2**p, the logarithm becomes particularly easy to calculate.
+
+Reference:
+Xavier Gourdon & Pascal Sebah, The Euler constant: gamma
+http://numbers.computation.free.fr/Constants/Gamma/gamma.pdf
+"""
+
+@constant_memo
+def gamma_fixed(prec):
+    prec += 30
+    # choose p such that exp(-4*(2**p)) < 2**-n
+    p = int(math.log((prec/4) * math.log(2), 2)) + 1
+    n = 1<<p
+    r = one = 1<<prec
+    H, A, B, npow, k, d = 0, 0, 0, 1, 1, 1
+    while r:
+        A += (r * H) >> prec
+        B += r
+        r = r * (n*n) // (k*k)
+        H += one // k
+        k += 1
+    S = ((A<<prec) // B) - p*log2_fixed(prec)
+    return S >> 30
+
+def fgamma(prec, rounding):
+    return normalize(gamma_fixed(prec+5), -prec-5, prec, rounding)