mpmath 0.2__zip → 0.4__zip

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)

mpmath-0.4/mpmath/lib/convert.py

@@ -0,0 +1,233 @@
+"""
+Functions for converting between raw mpmath floating-point numbers and
+other types and number representations (int, float, str...).
+"""
+
+from util import *
+from floatop import *
+from constants import flog2, flog10
+import math
+
+
+#----------------------------------------------------------------------
+# Strings
+#
+
+def to_digits_exp(s, dps):
+    """
+    Helper function for representing the floating-point number s as a
+    decimal with dps places. Returns (sign, string, exponent)
+    containing '' or '-', the decimal digits as a string, and an
+    integer for the decimal exponent.
+
+    If inexact, the decimal representation is rounded toward zero.
+    """
+
+    # Extract sign so it doesn't mess up the string digit count
+    sign = ''
+    if s[0] < 0:
+        sign = '-'
+    s = fabs(s, s[2], ROUND_FLOOR)
+    man, exp, bc = s
+
+    if not man:
+        return '', '0', 0
+
+    bitprec = int(dps * math.log(10,2)) + 10
+
+    # Cut down to size
+    # TODO: account for precision when doing this
+    exp_from_1 = exp + bc
+    if abs(exp) > 500:
+        # Set b = int(exp * log(2)/log(10))
+        # If exp is huge, we must use high-precision arithmetic to
+        # find the nearest power of ten
+        expprec = bitcount(exp) + 5
+        RF = ROUND_FLOOR
+        tmp = from_int(exp, expprec, RF)
+        tmp = fmul(tmp, flog2(expprec, RF), expprec, RF)
+        tmp = fdiv(tmp, flog10(expprec, RF), expprec, RF)
+        b = to_int(tmp)
+        s = fdiv(s, fpow(ften, b, bitprec, RF), bitprec, RF)
+        man, exp, bc = s
+        exponent = b
+    else:
+        exponent = 0
+
+    # First, calculate mantissa digits by converting to a binary
+    # fixed-point number and then converting that number to
+    # a decimal fixed-point number.
+    fixprec = max(bitprec - exp, 0)
+    fixdps = int(fixprec / math.log(10,2) + 0.5)
+    sf = make_fixed(s, fixprec)
+    sd = bin_to_radix(sf, fixprec, 10, fixdps)
+    digits = numeral(sd, base=10, size=dps)
+
+    exponent += len(digits) - fixdps - 1
+    return sign, digits, exponent
+
+
+def to_str(s, dps):
+    """Convert a raw mpf to a decimal floating-point literal with at
+    most `dps` decimal digits in the mantissa (not counting extra zeros
+    that may be inserted for visual purposes).
+
+    The literal is formatted so that it can be parsed back to a number
+    by to_str, float() or Decimal()."""
+
+    # to_digits_exp rounds to floor.
+    # This sometimes kills some instances of "...00001"
+    sign, digits, exponent = to_digits_exp(s, dps+3)
+
+    # Rounding up kills some instances of "...99999"
+    if len(digits) > dps and digits[dps] in '56789':
+        digits2 = str(int(digits[:dps]) + 1)
+        if len(digits2) > dps:
+            digits2 = digits2[:dps]
+            exponent += 1
+        digits = digits2
+    else:
+        digits = digits[:dps]
+
+    # Prettify numbers close to unit magnitude
+    if -(dps//3) < exponent < dps:
+        if exponent < 0:
+            digits = ("0"*(-exponent)) + digits
+            split = 1
+        else:
+            split = exponent + 1
+        exponent = 0
+    else:
+        split = 1
+
+    digits = (digits[:split] + "." + digits[split:])
+
+    # Clean up trailing zeros
+    digits = digits.rstrip('0')
+    if digits[-1] == ".":
+        digits += "0"
+
+    if exponent == 0: return sign + digits
+    if exponent > 0: return sign + digits + "e+" + str(exponent)
+    if exponent < 0: return sign + digits + "e" + str(exponent)
+
+
+def str_to_man_exp(x, base=10):
+    # Verify that the input is a valid float literal
+    float(x)
+    # Split into mantissa, exponent
+    x = x.lower()
+    parts = x.split('e')
+    if len(parts) == 1:
+        exp = 0
+    else: # == 2
+        x = parts[0]
+        exp = int(parts[1])
+    # Look for radix point in mantissa
+    parts = x.split('.')
+    if len(parts) == 2:
+        a, b = parts[0], parts[1].rstrip('0')
+        exp -= len(b)
+        x = a + b
+    x = int(x, base)
+    return x, exp
+
+def from_str(x, prec, rounding):
+    """Create a raw mpf from a decimal literal, rounding in the
+    specified direction if the input number cannot be represented
+    exactly as a binary floating-point number with the given number of
+    bits. The literal syntax accepted is the same as for Python
+    floats.
+
+    TODO: the rounding does not work properly for large exponents.
+    """
+    man, exp = str_to_man_exp(x, base=10)
+
+    # XXX: appropriate cutoffs & track direction
+    # note no factors of 5
+    if abs(exp) > 400:
+        s = from_int(man, prec+10, ROUND_FLOOR)
+        s = fmul(s, fpow(ften, exp, prec+10, ROUND_FLOOR), prec, rounding)
+    else:
+        if exp >= 0:
+            s = from_int(man * 10**exp, prec, rounding)
+        else:
+            s = from_rational(man, 10**-exp, prec, rounding)
+    return s
+
+# Binary string conversion. These are currently mainly used for debugging
+# and could use some improvement in the future
+
+def from_bstr(x):
+    man, exp = str_to_man_exp(x, base=2)
+    return normalize(man, exp, bitcount(man), ROUND_FLOOR)
+
+def to_bstr(x):
+    man, exp, bc = x
+    return numeral(man, size=bitcount(man), base=2) + ("e%i" % exp)
+
+
+#----------------------------------------------------------------------
+# Integers
+#
+
+def from_int(n, prec, rounding):
+    """Create a raw mpf from an integer, rounding if necessary."""
+    return normalize(n, 0, prec, rounding)
+
+def from_int_exact(n):
+    """Create a raw mpf from an integer, automatically choosing the
+    precision high enough to represent the integer exactly."""
+    t = trailing_zeros(n)
+    n >>= t
+    return (n, t, bitcount(n))
+
+def to_int(s):
+    """Convert a raw mpf to the nearest int, rounding down."""
+    man, exp, bc = s
+    return rshift(man, -exp, ROUND_DOWN)
+
+
+#----------------------------------------------------------------------
+# Regular python floats
+#
+
+def from_float(x, prec, rounding):
+    """Create a raw mpf from a Python float, rounding if necessary.
+    If prec >= 53, the result is guaranteed to represent exactly the
+    same number as the input."""
+    m, e = math.frexp(x)
+    return normalize(int(m*(1<<53)), e-53, prec, rounding)
+
+def to_float(s):
+    """Convert a raw mpf to a Python float. The result is exact if the
+    bitcount of s is <= 53 and no underflow/overflow occurs. An
+    OverflowError is raised if the number is too large to be
+    represented as a regular float."""
+    man, exp, bc = s
+    try:
+        return math.ldexp(man, exp)
+    except OverflowError:
+        # Try resizing the mantissa. Overflow may still happen here.
+        n = bc - 53
+        m = man >> n
+        return math.ldexp(m, exp + n)
+
+
+#----------------------------------------------------------------------
+# Rational numbers (for use by other libraries)
+#
+
+def from_rational(p, q, prec, rounding):
+    """Create a raw mpf from a rational number p/q, rounding if
+    necessary."""
+    return fdiv(from_int_exact(p), from_int_exact(q), prec, rounding)
+
+def to_rational(s):
+    """Convert a raw mpf to a rational number. Return integers (p, q)
+    such that s = p/q exactly. p and q are not reduced to lowest terms."""
+    man, exp, bc = s
+    if exp > 0:
+        return man * 2**exp, 1
+    else:
+        return man, 2**-exp