mpmath 0.2__zip → 0.4__zip

mpmath-0.4/mpmath/lib/floatop.py

@@ -0,0 +1,252 @@
+"""
+Functions for basic operations on raw mpfs: normalization, comparison,
+addition, subtraction, multiplication, division, integer powers.
+"""
+
+from util import *
+import random as _random
+
+
+# Some commonly needed raw mpfs
+fzero = (0, 0, 0)
+fone = (1, 0, 1)
+ftwo = (1, 1, 1)
+ften = (5, 1, 3)
+fhalf = (1, -1, 1)
+
+
+# Pre-computing and avoiding calls to trailing_zeros() in
+# normalize improves performance at 15-digit precision by ~15%
+shift_table = map(trailing_zeros, range(256))
+
+
+def normalize(man, exp, prec, rounding):
+    """Create a raw mpf with value (man * 2**exp), rounding in the
+    specified direction if the number of bits in the mantissa
+    exceeds the precision. Trailing zero bits are also stripped from
+    the mantissa to ensure that the representation is canonical."""
+
+    # The bit-level operations below assume a nonzero mantissa
+    if not man:
+        return fzero
+
+    # Count bits in the input mantissa. bitcount2 is slightly faster
+    # when man is expected to be small.
+    if prec < 100:
+        bc = bitcount2(man)
+    else:
+        bc = bitcount(man)
+
+    # Cut mantissa down to size
+    if bc > prec:
+        man = rshift(man, bc-prec, rounding)
+        exp += (bc - prec)
+        bc = prec
+    # Strip trailing zeros
+    if not man & 1:
+        # To within the nearest byte
+        while not man & 0xff:
+            man >>= 8
+            exp += 8
+            bc -= 8
+        t = shift_table[man & 0xff]
+        man >>= t
+        exp += t
+        bc -= t
+    # If result is +/- a power of two due to rounding up in rshift(),
+    # bc may be wrong
+    if man == 1 or man == -1:
+        bc = 1
+    return (man, exp, bc)
+
+
+def feq(s, t):
+    """Test equality of two raw mpfs. (This is simply tuple comparion;
+    this function is provided only for completeness)."""
+    return s == t
+
+
+def fcmp(s, t):
+    """Compare the raw mpfs s and t. Return -1 if s < t, 0 if s == t,
+    and 1 if s > t. (Same convention as Python's cmp() function.)"""
+
+    # In principle, a comparison amounts to determining the sign of s-t.
+    # A full subtraction is relatively slow, however, so we first try to
+    # look at the components.
+    sman, sexp, sbc = s
+    tman, texp, tbc = t
+
+    # Very easy cases: check for zeros and opposite signs
+    if not tman: return cmp(sman, 0)
+    if not sman: return cmp(0, tman)
+    if sman > 0 and tman < 0: return 1
+    if sman < 0 and tman > 0: return -1
+
+    # This reduces to direct integer comparison
+    if sexp == texp: return cmp(sman, tman)
+
+    # Check position of the highest set bit in each number. If
+    # different, there is certainly an inequality.
+    a = sbc + sexp
+    b = tbc + texp
+    if sman > 0:
+        if a < b: return -1
+        if a > b: return 1
+    else:
+        if a < b: return 1
+        if a > b: return -1
+
+    # Both numbers have the same highest bit. Subtract to find
+    # how the lower bits compare.
+    return cmp(fsub(s, t, 5, ROUND_FLOOR)[0], 0)
+
+
+def fpos(s, prec, rounding):
+    """Calculate 0+s for a raw mpf (i.e., just round s to the specified
+    precision, or return s unchanged if its mantissa is smaller than
+    the precision)."""
+    return normalize(s[0], s[1], prec, rounding)
+
+
+def fadd(s, t, prec, rounding):
+    """Add two raw mpfs and round the result to the specified precision,
+    in the specified direction."""
+
+    # We will assume below that s has the higher exponent.
+    if t[1] > s[1]:
+        s, t = t, s
+    sman, sexp, sbc = s
+    tman, texp, tbc = t
+
+    # Check if one operand is zero. Zero always has exp = 0; if the
+    # other operand has a large exponent, its mantissa will unnecessarily
+    # be shifted a huge number of bits if we don't check for this case.
+    if not tman: return normalize(sman, sexp, prec, rounding)
+    if not sman: return normalize(tman, texp, prec, rounding)
+
+    #------------------------------------------------------------------------
+    # More generally, if one number is huge and the other is small,
+    # and in particular, if their mantissas don't overlap at all at
+    # the current precision level, we can avoid work.
+    #       precision
+    #    |            |
+    #     111111111
+    #  +                 222222222
+    #     ------------------------
+    #  #  1111111110000...
+    #
+    delta = (sbc + sexp) - (tbc + texp)
+    if delta > prec + 5:   # an arbitrary number ~> 3
+        # The result may have to be rounded up or down. So we shift s
+        # and add a dummy bit outside the precision range to force
+        # rounding.
+        offset = min(delta + 3, prec+3)
+        sman <<= offset
+        if tman > 0:
+            sman += 1
+        else:
+            sman -= 1
+        return normalize(sman, sexp-offset, prec, rounding)
+
+    #------------------------------------------------------------------------
+    #  General algorithm: we set min(s.exp, t.exp) = 0, perform exact integer
+    #  addition, and then round the result.
+    #                   exp = 0
+    #                       |
+    #                       v
+    #          11111111100000   <-- s.man (padded with zeros from shifting)
+    #      +        222222222   <-- t.man (no shifting necessary)
+    #          --------------
+    #      =   11111333333333
+    #
+    return normalize(tman+(sman<<(sexp-texp)), texp, prec, rounding)
+
+
+def fsub(s, t, prec, rounding):
+    """Return the difference of two raw mpfs, s-t. This function is
+    simply a wrapper of fadd that changes the sign of t."""
+    return fadd(s, (-t[0], t[1], t[2]), prec, rounding)
+
+
+def fneg(s, prec, rounding):
+    """Negate a raw mpf (return -s), rounding the result to the
+    specified precision."""
+    return normalize(-s[0], s[1], prec, rounding)
+
+
+def fneg_exact(s):
+    """Negate a raw mpf (return -s), without performing any rounding."""
+    return (-s[0], s[1], s[2])
+
+
+def fabs(s, prec, rounding):
+    """Return abs(s) of the raw mpf s, rounded to the specified
+    precision."""
+    man, exp, bc = s
+    if man < 0:
+        return normalize(-man, exp, prec, rounding)
+    return normalize(man, exp, prec, rounding)
+
+
+def fmul(s, t, prec, rounding):
+    """Return the product of two raw mpfs, s*t, rounded to the
+    specified precision."""
+    sman, sexp, sbc = s
+    tman, texp, tbc = t
+    # This is very simple. A possible optimization would be to throw
+    # away some bits when prec is much smaller than sbc+tbc
+    return normalize(sman*tman, sexp+texp, prec, rounding)
+
+
+def fdiv(s, t, prec, rounding):
+    """Floating-point division"""
+    sman, sexp, sbc = s
+    tman, texp, tbc = t
+
+    # Same strategy as for addition: if there is a remainder, perturb
+    # the result a few bits outside the precision range before rounding
+    extra = max(prec - sbc + tbc + 5, 5)
+    quot, rem = divmod(sman<<extra, tman)
+    if rem:
+        quot = (quot << 5) + 1
+        extra += 5
+    return normalize(quot, sexp-texp-extra, prec, rounding)
+
+
+def fshift_exact(s, n):
+    """Quickly multiply the raw mpf s by 2**n without rounding."""
+    man, exp, bc = s
+    if not man:
+        return s
+    return man, exp+n, bc
+
+
+# TODO: use directed rounding all the way through (and, account for signs?)
+def fpow(s, n, prec, rounding):
+    """Compute s**n, where n is an integer"""
+    n = int(n)
+    if n == 0: return fone
+    if n == 1: return normalize(s[0], s[1], prec, rounding)
+    if n == 2: return fmul(s, s, prec, rounding)
+    if n == -1: return fdiv(fone, s, prec, rounding)
+    if n < 0:
+        return fdiv(fone, fpow(s, -n, prec+3, ROUND_FLOOR), prec, rounding)
+    # Now we perform binary exponentiation. Need to estimate precision
+    # to avoid rounding from temporary operations. Roughly log_2(n)
+    # operations are performed.
+    prec2 = prec + int(4*math.log(n, 2) + 4)
+    man, exp, bc = normalize(s[0], s[1], prec2, ROUND_FLOOR)
+    pm, pe, pbc = fone
+    while n:
+        if n & 1:
+            pm, pe, pbc = normalize(pm*man, pe+exp, prec2, ROUND_FLOOR)
+            n -= 1
+        man, exp, bc = normalize(man*man, exp+exp, prec2, ROUND_FLOOR)
+        n = n // 2
+    return normalize(pm, pe, prec, rounding)
+
+
+def frand(prec):
+    """Return a raw mpf chosen randomly from [0, 1), with prec bits
+    in the mantissa."""
+    return normalize(_random.randrange(0, 1<<prec), -prec, prec, ROUND_FLOOR)

mpmath-0.4/mpmath/lib/functions.py

@@ -0,0 +1,350 @@
+"""
+Transcendental functions for real numbers:
+* exp
+* log
+* sin/cos/tan
+* sinh/cosh/tanh
+
+"""
+
+from util import *
+from floatop import *
+from squareroot import *
+from constants import *
+from convert import *
+
+
+"""
+The exponential function has a rapidly convergent Maclaurin series:
+
+    exp(x) = 1 + x + x**2/2! + x**3/3! + x**4/4! + ...
+
+The series can be summed very easily using fixed-point arithmetic.
+The convergence can be improved further, using a trick due to
+Richard P. Brent: instead of computing exp(x) directly, we choose a
+small integer r (say, r=10) and compute exp(x/2**r)**(2**r).
+
+The optimal value for r depends on the Python platform, the magnitude
+of x and the target precision, and has to be estimated from
+experimental timings. One test with x ~= 0.3 showed that
+r = 2.2*prec**0.42 gave a good fit to the optimal values for r for
+prec between 1 and 10000 bits, on one particular machine.
+
+This optimization makes the summation about twice as fast at
+low precision levels and much faster at high precision
+(roughly five times faster at 1000 decimal digits).
+
+If |x| is very large, we first rewrite it as t + n*log(2) with the
+integer n chosen such that |t| <= log(2), and then calculate
+exp(x) as exp(t)*(2**n), using the Maclaurin series for exp(t)
+(the multiplication by 2**n just amounts to shifting the exponent).
+"""
+
+def exp_series(x, prec):
+    r = int(2.2 * prec ** 0.42)
+    # XXX: more careful calculation of guard bits
+    guards = r + 3
+    if prec > 60:
+        guards += int(math.log(prec))
+    prec2 = prec + guards
+    x = rshift_quick(x, r - guards)
+    s = (1 << prec2) + x
+    a = x
+    k = 2
+    # Sum exp(x/2**r)
+    while 1:
+        a = ((a*x) >> prec2) // k
+        if not a: break
+        s += a
+        k += 1
+    # Calculate s**(2**r) by repeated squaring
+    for j in range(r):
+        s = (s*s) >> prec2
+    return s >> guards
+
+def fexp(x, prec, rounding):
+    man, exp, bc = x
+    # extra precision needs to be similar in magnitude to log_2(|x|)
+    prec2 = prec + 6 + max(0, bc+exp)
+    t = make_fixed(x, prec2)
+    # abs(x) > 1?
+    if exp+bc > 1:  #fcmp(fabs(x), fone) > 0:
+        lg2 = log2_fixed(prec2)
+        n, t = divmod(t, lg2)
+    else:
+        n = 0
+    return normalize(exp_series(t, prec2), -prec2+n, prec, rounding)
+
+
+"""
+The basic strategy for computing log(x) is to set r = log(x) and use
+Newton's method to solve the equation exp(r) = x. We set the initial
+value r_0 to math.log(x) and then iterate r_{n+1} = r_n + exp(-r_n) - 1
+until convergence. As with square roots, we increase the working
+precision dynamically during the process so that only one full-precision
+evaluation of exp is required.
+
+log(x) is small for most inputs, so the r values can safely be
+computed using fixed-point arithmetic. However, when x has a very
+large or small exponent, we can improve performance through the
+normalization log(t * 2**n) = log(t) + n*log(2), choosing n such
+that 0.5 <= t <= 1 (for example).
+
+There are some caveats: if x is extremely close to 1, the working
+precision must be increased to maintain high relative precision in the
+output (alternatively, the series approximation for log(1+x) could
+be used in that case).
+"""
+
+# This function performs the Newton iteration using fixed-point
+# arithmetic. x is assumed to have magnitude ~= 1
+def _log_newton(x, prec):
+    extra = 8
+    # 50-bit approximation
+    #r = int(_clog(Float((x, -prec), 64)) * 2.0**50)
+    fx = math.log(to_float((x, -prec, bitcount(x))))
+    r = int(fx * 2.0**50)
+    prevp = 50
+    for p in giant_steps(50, prec+extra):
+        rb = lshift_quick(r, p-prevp)
+        e = exp_series(-rb, p)
+        r = rb + ((rshift_quick(x, prec-p)*e)>>p) - (1 << p)
+        prevp = p
+    return r >> extra
+
+def flog(x, prec, rounding):
+    if x == fzero: raise ValueError, "logarithm of 0"
+    if x == fone:  return fzero
+    man, exp, bc = x
+    if man < 0: raise ValueError, "logarithm of a negative number"
+    # Estimated precision needed for log(t) + n*log(2)
+    prec2 = prec + int(math.log(1+abs(bc+exp), 2)) + 10
+    # Watch out for the case when x is very close to 1
+    if -1 < bc + exp < 2:
+        near_one = fabs(fsub(x, fone, STANDARD_PREC, ROUND_FLOOR), STANDARD_PREC, ROUND_FLOOR)
+        if near_one == 0:
+            return fzero
+        # estimate how close
+        prec2 += -(near_one[1]) - bitcount(near_one[0])
+    # Separate mantissa and exponent, calculate, join parts
+    t = rshift_quick(man, bc-prec2)
+    l = _log_newton(t, prec2)
+    a = (exp + bc) * log2_fixed(prec2)
+    return normalize(l+a, -prec2, prec, rounding)
+
+
+
+"""
+We compute sin(x) around 0 from its Taylor series, and cos(x) around 0
+from sqrt(1-sin(x)**2). This way we can simultaneously compute sin and
+cos, which are often needed together (e.g. for the tangent function or
+the complex exponential), with little extra cost compared to computing
+just one of them. The main reason for computing sin first (and not sin
+from cos) is to obtain high relative accuracy for x extremely close to
+0, where the operation sqrt(1-cos(x)**2) can cause huge cancellations.
+
+For any value of x, we can reduce it to the interval A = [-pi/4, pi/4]
+(where the Taylor series converges quickly) by translations, changing
+signs, and switching the roles of cos and sin:
+
+   A : sin(x) = sin(x)           cos(x) = cos(x)
+   B : sin(x) = cos(x-pi/2)      cos(x) = -sin(x-pi/2)
+   C : sin(x) = -sin(x-pi)       cos(x) = -cos(x-pi)
+   D : sin(x) = -cos(x-3*pi/2)   cos(x) = sin(x-3*pi/2)
+
+|     A      |      B     |      C     |     D     |
+v            v            v            v           v
+
+   1 |  ____   ..........                            ____
+     |      _..          ..                        __
+     |      . __           .                     __
+     |    ..    _           ..                  _
+     |   .       __           .               __
+-----| -.----------_-----------.-------------_-----------
+     | .            _           ..          _           .
+     |               __           .       __           .
+     |                 _           ..    _           ..
+     |                  __           . __           .
+     |                    __         _..          ..
+  -1 |                      _________   ..........
+      0                       pi                     2*pi
+
+
+TODO: could use cos series too when extremely close to 0
+"""
+
+def _sin_series(x, prec):
+    x2 = (x*x) >> prec
+    s = a = x
+    k = 3
+    while a:
+        a = ((a * x2) >> prec) // (-k*(k-1))
+        s += a
+        k += 2
+    return s
+
+def _trig_reduce(x, prec):
+    pi_ = pi_fixed(prec)
+    pi4 = pi_ >> 2
+    pi2 = pi_ >> 1
+    n, rem = divmod(x + pi4, pi2)
+    rem -= pi4
+    return n, rem
+
+def cos_sin(x, prec, rounding):
+    """Simultaneously compute (cos(x), sin(x)) for real x."""
+    man, exp, bc = x
+    bits_from_unit = abs(bc + exp)
+    prec2 = prec + bits_from_unit + 15
+    xf = make_fixed(x, prec2)
+    n, rx = _trig_reduce(xf, prec2)
+    case = n % 4
+    one = 1 << prec2
+    if case == 0:
+        s = _sin_series(rx, prec2)
+        c = sqrt_fixed(one - ((s*s)>>prec2), prec2)
+    elif case == 1:
+        c = -_sin_series(rx, prec2)
+        s = sqrt_fixed(one - ((c*c)>>prec2), prec2)
+    elif case == 2:
+        s = -_sin_series(rx, prec2)
+        c = -sqrt_fixed(one - ((s*s)>>prec2), prec2)
+    elif case == 3:
+        c = _sin_series(rx, prec2)
+        s = -sqrt_fixed(one - ((c*c)>>prec2), prec2)
+    c = normalize(c, -prec2, prec, rounding)
+    s = normalize(s, -prec2, prec, rounding)
+    return c, s
+
+def fcos(x, prec, rounding):
+    return cos_sin(x, prec, rounding)[0]
+
+def fsin(x, prec, rounding):
+    return cos_sin(x, prec, rounding)[1]
+
+def ftan(x, prec, rounding):
+    c, s = cos_sin(x, prec+6, ROUND_FLOOR)
+    return fdiv(s, c, prec, rounding)
+
+
+#----------------------------------------------------------------------
+# Hyperbolic functions
+#
+
+def _sinh_series(x, prec):
+    x2 = (x*x) >> prec
+    s = a = x
+    k = 3
+    while a:
+        a = ((a * x2) >> prec) // (k*(k-1))
+        s += a
+        k += 2
+    return s
+
+def cosh_sinh(x, prec, rounding):
+    """Simultaneously compute (cosh(x), sinh(x)) for real x"""
+
+    man, exp, bc = x
+    high_bit = exp + bc
+    prec2 = prec + 6
+
+    if high_bit < -3:
+        # Extremely close to 0, sinh(x) ~= x and cosh(x) ~= 1
+        # TODO: support directed rounding
+        if high_bit < -prec-2:
+            return (fone, fpos(x, prec, rounding))
+
+        # Avoid cancellation when computing sinh
+        # TODO: might be faster to use sinh series directly
+        prec2 += (-high_bit) + 4
+
+    # In the general case, we use
+    #    cosh(x) = (exp(x) + exp(-x))/2
+    #    sinh(x) = (exp(x) - exp(-x))/2
+    # and note that the exponential only needs to be computed once.
+    ep = fexp(x, prec2, ROUND_FLOOR)
+    em = fdiv(fone, ep, prec2, ROUND_FLOOR)
+    ch = fshift_exact(fadd(ep, em, prec, rounding), -1)
+    sh = fshift_exact(fsub(ep, em, prec, rounding), -1)
+    return ch, sh
+
+def fcosh(x, prec, rounding):
+    """Compute cosh(x) for a real argument x"""
+    return cosh_sinh(x, prec, rounding)[0]
+
+def fsinh(x, prec, rounding):
+    """Compute sinh(x) for a real argument x"""
+    return cosh_sinh(x, prec, rounding)[1]
+
+def ftanh(x, prec, rounding):
+    """Compute tanh(x) for a real argument x"""
+    ch, sh = cosh_sinh(x, prec+6, ROUND_FLOOR)
+    return fdiv(sh, ch, prec, rounding)
+
+
+#----------------------------------------------------------------------
+# Inverse tangent
+#
+
+"""
+Near x = 0, use atan(x) = x - x**3/3 + x**5/5 - ...
+Near x = 1, use atan(x) = y/x * (1 + 2/3*y + 2*4/3/5*y**2 + ...)
+where y = x**2/(1+x**2).
+
+TODO: these series are not impressively fast. It is probably better
+to calculate atan from tan, using Newton's method or even the
+secant method.
+"""
+
+def _atan_series_1(x, prec, rounding):
+    man, exp, bc = x
+    # Increase absolute precision when extremely close to 0
+    bc = bitcount(man)
+    diff = -(bc + exp)
+    prec2 = prec
+    if diff > 10:
+        if 3*diff - 4 > prec:  # x**3 term vanishes; atan(x) ~x
+            return normalize(man, exp, prec, rounding)
+        prec2 = prec + diff
+    prec2 += 15  # XXX: better estimate for number of guard bits
+    x = make_fixed(x, prec2)
+    x2 = (x*x)>>prec2; one = 1<<prec2; s=a=x
+    for n in xrange(1, 1000000):
+        a = (a*x2) >> prec2
+        s += a // ((-1)**n * (n+n+1))
+        if -100 < a < 100:
+            break
+    return normalize(s, -prec2, prec, rounding)
+
+def _atan_series_2(x, prec, rounding):
+    prec2 = prec + 15
+    x = make_fixed(x, prec2)
+    one = 1<<prec2; x2 = (x*x)>>prec2; y=(x2<<prec2)//(one+x2)
+    s = a = one
+    for n in xrange(1, 1000000):
+        a = ((a*y)>>prec2) * (2*n) // (2*n+1)
+        if a < 100:
+            break
+        s += a
+    return normalize(y*s//x, -prec2, prec, rounding)
+
+_cutoff_1 = (5, -3, 3)   # ~0.6
+_cutoff_2 = (3, -1, 2)   # 1.5
+
+def fatan(x, prec, rounding):
+    if x[0] < 0:
+        t = fatan(fneg_exact(x), prec+4, ROUND_FLOOR)
+        return normalize(-t[0], t[1], prec, rounding)
+    if fcmp(x, _cutoff_1) < 0:
+        return _atan_series_1(x, prec, rounding)
+    if fcmp(x, _cutoff_2) < 0:
+        return _atan_series_2(x, prec, rounding)
+    # For large x, use atan(x) = pi/2 - atan(1/x)
+    if x[1] > 10*prec:
+        pi = fpi(prec, rounding)
+        pihalf = pi[0], pi[1]-1, pi[2]
+    else:
+        pi = fpi(prec+4, ROUND_FLOOR)
+        pihalf = pi[0], pi[1]-1, pi[2]
+        t = fatan(fdiv(fone, x, prec+4, ROUND_FLOOR), prec+4, ROUND_FLOOR)
+        return fsub(pihalf, t, prec, rounding)