mpmath 0.2__zip → 0.4__zip

{mpmath-0.2 → mpmath-0.4}/setup.py

@@ -2,10 +2,10 @@ from distutils.core import setup
 
 setup(name='mpmath',
       description = 'Python library for arbitrary-precision floating-point arithmetic',
-      version='0.2',
+      version='0.4',
       url='http://mpmath.googlecode.com',
       author='Fredrik Johansson',
       author_email='fredrik.johansson@gmail.com',
       license = 'BSD',
-      packages=['mpmath'],
+      packages=['mpmath', 'mpmath/lib'],
      )

mpmath-0.4/tests/benchmark.py

@@ -0,0 +1,139 @@
+from mpmath import *
+from mpmath.lib import *
+from decimal import getcontext, Decimal
+import dmath
+from random import seed, random, randint
+
+def getrandom(type):
+    if type == 'mpf':
+        return mpf(random() * 2.0**randint(-10, 10)) ** 0.5
+    if type == 'mpfval':
+        return (mpf(random() * 2.0**randint(-10, 10)) ** 0.5).val
+    if type == 'Decimal':
+        return Decimal(repr(random() * 2.0**randint(-10, 10))).sqrt()
+    raise TypeError
+
+def rndnums(type, N):
+    seed(1234)
+    xs = [getrandom(type) for i in xrange(N)]
+    ys = xs[::-1]
+    xys = zip(xs, ys)
+    return xs, ys, xys
+
+def setprec(type, prec):
+    if type == 'Decimal':
+        getcontext().prec = prec
+    else:
+        mpf.dps = prec
+        # change prec value to bits for mpfval use
+        prec = mpf.prec
+    return prec
+
+testcode = \
+"""
+def testit(prec, N):
+    from time import clock
+    RF = ROUND_HALF_EVEN
+    prec = setprec('TYPE', prec)
+    xs, ys, xys = rndnums('TYPE', N)
+    t = 1e100
+    for i in range(3):
+        t1 = clock()
+        for x, y in xys:
+            OP
+        t2 = clock()
+        t = min(t, t2-t1)
+    return t
+"""
+
+tests = []
+atests = [
+  ('Convert to integer (int(x))', 'int(x)', 'int(x)', 'to_int(x)'),
+  ('Convert to string (str(x))', 'str(x)', 'str(x)', 'to_str(x, int(prec/3.321))'),
+  ('Convert to float (float(x))', 'float(x)', 'float(x)', 'to_float(x)'),
+  ('Equality (x==y)', 'x==y', 'x==y', 'feq(x, y)'),
+  ('Comparison (x<y)', 'x<y', 'x<y', 'fcmp(x, y) < 0'),
+  ('Addition (x+y)', 'x+y', 'x+y', 'fadd(x, y, prec, RF)'),
+  ('Subtraction (x-y)', 'x+y', 'x+y', 'fsub(x, y, prec, RF)'),
+  ('Multiplication (x*y)', 'x*y', 'x*y', 'fmul(x, y, prec, RF)'),
+  ('Division (x/y)', 'x/y', 'x/y', 'fdiv(x, y, prec, RF)'),
+  ('Square root (x^0.5)', 'x.sqrt()', 'sqrt(x)', 'fsqrt(x, prec, RF)'),
+  ('Integer power (x^42)', 'x**42', 'x**42', 'fpow(x, 42, prec, RF)'),
+  ('Exponential function (exp(x))', 'dmath.exp(x)', 'exp(x)', 'fexp(x, prec, RF)'),
+  ('Natural logarithm (log(x))', 'dmath.log(x+1)', 'log(x)', 'flog(x, prec, RF)'),
+  ('Sine (sin(x))', 'dmath.sin(x)', 'sin(x)', 'fsin(x, prec, RF)'),
+  ('Tangent (tan(x))', 'dmath.tan(x)', 'tan(x)', 'ftan(x, prec, RF)'),
+  ('Inverse tangent(atan(x))', 'dmath.atan(x)', 'atan(x)', 'fatan(x, prec, RF)'),
+  ('Hyperbolic cosine (cosh(x))', 'dmath.cosh(x)', 'cosh(x)', 'fcosh(x, prec, RF)')
+]
+
+slow = ["exp", "log", "sin", "tan", "cos"]
+
+for op in atests:
+    cases = [op[0]]
+    if op[1]:
+        exec testcode.replace("OP", op[1]).replace("TYPE", "Decimal")
+        cases += [testit]
+    else:
+        cases += [None]
+    exec testcode.replace("OP", op[2]).replace("TYPE", "mpf")
+    cases += [testit]
+    exec testcode.replace("OP", op[3]).replace("TYPE", "mpfval")
+    cases += [testit]
+    tests.append(cases)
+
+def rd(x):
+    if x > 100000: return int(x // 10000) * 10000
+    if x > 10000: return int(x // 1000) * 1000
+    if x > 1000: return int(x // 100) * 100
+    if x > 100: return int(x // 10) * 10
+    return int(x)
+
+def runtests():
+    results = []
+    for test in tests:
+        name, dectest, mpftest, mpfvaltest = test
+        if any(s in name for s in slow):
+            N = 1
+            precs = [15, 30, 100, 300]
+        else:
+            N = 10
+            precs = [15, 30, 100, 300, 1000]
+        header_name = "*" + name + "*"
+        rows = []
+        for prec in precs:
+            print name, prec
+            if dectest is None:
+                t1 = 1e1000-1e1000
+            else:
+                t1 = dectest(prec, N)
+            t2 = mpftest(prec, N)
+            t3 = mpfvaltest(prec, N)
+            s = []
+            s += ["%i" % prec]
+            s += [str(rd(N/t1))]
+            s += [str(rd(N/t2)) + (" (%.1fx)" % (t1/t2))]
+            s += [str(rd(N/t3)) + (" (%.1fx)" % (t1/t3))]
+            rows.append(s)
+        results.append((header_name, rows))
+    return results
+
+import gc
+gc.disable()
+results1 = runtests()
+import psyco
+psyco.full()
+results2 = runtests()
+
+import sys
+sys.stdout = open("results.txt", "w")
+
+for r1, r2 in zip(results1, results2):
+    name = r1[0]
+    print name
+    print "|| *digits* || *Decimal* || *mpf* ||  *raw mpf* || *Decimal+psyco* || *mpf+psyco* || *raw mpf+psyco* ||"
+    for a, b in zip(r1[1], r2[1]):
+        cols = a + b[1:]
+        print "|| " + (" || ".join(cols)) + " ||"
+    print
+

mpmath-0.4/tests/runtests.py

@@ -0,0 +1,5 @@
+#!C:\Python25\python.exe 
+
+#from _findpy import py 
+import py
+py.test.cmdline.main() 

mpmath-0.4/tests/test_bitwise.py

@@ -0,0 +1,110 @@
+"""
+Test bit-level integer operations
+"""
+
+from mpmath.lib import *
+
+def test_bitcount():
+    assert bitcount(0) == 0
+    assert bitcount(1) == 1
+    assert bitcount(7) == 3
+    assert bitcount(8) == 4
+    assert bitcount(2**100) == 101
+    assert bitcount(2**100-1) == 100
+    assert bitcount(-(2**100)) == 101
+    assert bitcount(-(2**100-1)) == 100
+
+def test_trailing_zeros():
+    assert trailing_zeros(0) == 0
+    assert trailing_zeros(1) == 0
+    assert trailing_zeros(2) == 1
+    assert trailing_zeros(7) == 0
+    assert trailing_zeros(8) == 3
+    assert trailing_zeros(2**100) == 100
+    assert trailing_zeros(2**100-1) == 0
+
+def test_round_down():
+    assert normalize(0, -4, 4, ROUND_DOWN)[:2] == (0, 0)
+    assert normalize(0xf0, -4, 4, ROUND_DOWN)[:2] == (15, 0)
+    assert normalize(0xf1, -4, 4, ROUND_DOWN)[:2] == (15, 0)
+    assert normalize(0xff, -4, 4, ROUND_DOWN)[:2] == (15, 0)
+    assert normalize(-0xf0, -4, 4, ROUND_DOWN)[:2] == (-15, 0)
+    assert normalize(-0xf1, -4, 4, ROUND_DOWN)[:2] == (-15, 0)
+    assert normalize(-0xff, -4, 4, ROUND_DOWN)[:2] == (-15, 0)
+
+def test_round_up():
+    assert normalize(0, -4, 4, ROUND_UP)[:2] == (0, 0)
+    assert normalize(0xf0, -4, 4, ROUND_UP)[:2] == (15, 0)
+    assert normalize(0xf1, -4, 4, ROUND_UP)[:2] == (1, 4)
+    assert normalize(0xff, -4, 4, ROUND_UP)[:2] == (1, 4)
+    assert normalize(-0xf0, -4, 4, ROUND_UP)[:2] == (-15, 0)
+    assert normalize(-0xf1, -4, 4, ROUND_UP)[:2] == (-1, 4)
+    assert normalize(-0xff, -4, 4, ROUND_UP)[:2] == (-1, 4)
+
+def test_round_floor():
+    assert normalize(0, -4, 4, ROUND_FLOOR)[:2] == (0, 0)
+    assert normalize(0xf0, -4, 4, ROUND_FLOOR)[:2] == (15, 0)
+    assert normalize(0xf1, -4, 4, ROUND_FLOOR)[:2] == (15, 0)
+    assert normalize(0xff, -4, 4, ROUND_FLOOR)[:2] == (15, 0)
+    assert normalize(-0xf0, -4, 4, ROUND_FLOOR)[:2] == (-15, 0)
+    assert normalize(-0xf1, -4, 4, ROUND_FLOOR)[:2] == (-1, 4)
+    assert normalize(-0xff, -4, 4, ROUND_FLOOR)[:2] == (-1, 4)
+
+def test_round_ceiling():
+    assert normalize(0, -4, 4, ROUND_CEILING)[:2] == (0, 0)
+    assert normalize(0xf0, -4, 4, ROUND_CEILING)[:2] == (15, 0)
+    assert normalize(0xf1, -4, 4, ROUND_CEILING)[:2] == (1, 4)
+    assert normalize(0xff, -4, 4, ROUND_CEILING)[:2] == (1, 4)
+    assert normalize(-0xf0, -4, 4, ROUND_CEILING)[:2] == (-15, 0)
+    assert normalize(-0xf1, -4, 4, ROUND_CEILING)[:2] == (-15, 0)
+    assert normalize(-0xff, -4, 4, ROUND_CEILING)[:2] == (-15, 0)
+
+def test_round_half_up():
+    assert normalize(0, -4, 4, ROUND_HALF_UP)[:2] == (0, 0)
+    assert normalize(0xf0, -4, 4, ROUND_HALF_UP)[:2] == (15, 0)
+    assert normalize(0xf7, -4, 4, ROUND_HALF_UP)[:2] == (15, 0)
+    assert normalize(0xf8, -4, 4, ROUND_HALF_UP)[:2] == (1, 4)
+    assert normalize(0xf9, -4, 4, ROUND_HALF_UP)[:2] == (1, 4)
+    assert normalize(0xff, -4, 4, ROUND_HALF_UP)[:2] == (1, 4)
+    assert normalize(-0xf0, -4, 4, ROUND_HALF_UP)[:2] == (-15, 0)
+    assert normalize(-0xf7, -4, 4, ROUND_HALF_UP)[:2] == (-15, 0)
+    assert normalize(-0xf8, -4, 4, ROUND_HALF_UP)[:2] == (-1, 4)
+    assert normalize(-0xf9, -4, 4, ROUND_HALF_UP)[:2] == (-1, 4)
+    assert normalize(-0xff, -4, 4, ROUND_HALF_UP)[:2] == (-1, 4)
+
+def test_round_half_down():
+    assert normalize(0, -4, 4, ROUND_HALF_DOWN)[:2] == (0, 0)
+    assert normalize(0xf0, -4, 4, ROUND_HALF_DOWN)[:2] == (15, 0)
+    assert normalize(0xf7, -4, 4, ROUND_HALF_DOWN)[:2] == (15, 0)
+    assert normalize(0xf8, -4, 4, ROUND_HALF_DOWN)[:2] == (15, 0)
+    assert normalize(0xf9, -4, 4, ROUND_HALF_DOWN)[:2] == (1, 4)
+    assert normalize(0xff, -4, 4, ROUND_HALF_DOWN)[:2] == (1, 4)
+    assert normalize(-0xf0, -4, 4, ROUND_HALF_DOWN)[:2] == (-15, 0)
+    assert normalize(-0xf7, -4, 4, ROUND_HALF_DOWN)[:2] == (-15, 0)
+    assert normalize(-0xf8, -4, 4, ROUND_HALF_DOWN)[:2] == (-15, 0)
+    assert normalize(-0xf9, -4, 4, ROUND_HALF_DOWN)[:2] == (-1, 4)
+    assert normalize(-0xff, -4, 4, ROUND_HALF_DOWN)[:2] == (-1, 4)
+
+def test_round_half_even():
+    assert normalize(0, -4, 4, ROUND_HALF_EVEN)[:2] == (0, 0)
+    assert normalize(0xf0, -4, 4, ROUND_HALF_EVEN)[:2] == (15, 0)
+    assert normalize(0xf7, -4, 4, ROUND_HALF_EVEN)[:2] == (15, 0)
+    assert normalize(0xf8, -4, 4, ROUND_HALF_EVEN)[:2] == (1, 4)    # 1111.1000 -> 10000.0
+    assert normalize(0xf9, -4, 4, ROUND_HALF_EVEN)[:2] == (1, 4)    # 1111.1001 -> 10000.0
+    assert normalize(0xe8, -4, 4, ROUND_HALF_EVEN)[:2] == (7, 1)    # 1110.1000 -> 1110.0
+    assert normalize(0xe9, -4, 4, ROUND_HALF_EVEN)[:2] == (15, 0)     # 1110.1001 -> 1111.0
+    assert normalize(-0xf0, -4, 4, ROUND_HALF_EVEN)[:2] == (-15, 0)
+    assert normalize(-0xf7, -4, 4, ROUND_HALF_EVEN)[:2] == (-15, 0)
+    assert normalize(-0xf8, -4, 4, ROUND_HALF_EVEN)[:2] == (-1, 4)
+    assert normalize(-0xf9, -4, 4, ROUND_HALF_EVEN)[:2] == (-1, 4)
+    assert normalize(-0xe8, -4, 4, ROUND_HALF_EVEN)[:2] == (-7, 1)
+    assert normalize(-0xe9, -4, 4, ROUND_HALF_EVEN)[:2] == (-15, 0)
+
+def test_rounding_bugs():
+    # 1 less than power-of-two cases
+    assert normalize(72057594037927935, -56, 53, ROUND_UP) == (1, 0, 1)
+    assert normalize(73786976294838205979L, -65, 53, ROUND_HALF_EVEN) == (1, 1, 1)
+    assert normalize(31, 0, 4, ROUND_UP) == (1, 5, 1)
+    assert normalize(-31, 0, 4, ROUND_FLOOR) == (-1, 5, 1)
+    assert normalize(255, 0, 7, ROUND_UP) == (1, 8, 1)
+    assert normalize(-255, 0, 7, ROUND_FLOOR) == (-1, 8, 1)

mpmath-0.4/tests/test_compatibility.py

@@ -0,0 +1,51 @@
+from mpmath import *
+from random import seed, randint, random
+
+# Test compatibility with Python floats, which are
+# IEEE doubles (53-bit)
+
+N = 5000
+seed(1)
+
+# Choosing exponents between roughly -140, 140 ensures that
+# the Python floats don't overflow or underflow
+xs = [(random()-1) * 10**randint(-140, 140) for x in range(N)]
+ys = [(random()-1) * 10**randint(-140, 140) for x in range(N)]
+
+# include some equal values
+ys[int(N*0.8):] = xs[int(N*0.8):]
+
+def test_double_compatibility():
+    mpf.prec = 53
+    mpf.round_default()
+    for x, y in zip(xs, ys):
+        mpx = mpf(x)
+        mpy = mpf(y)
+        assert mpf(x) == x
+        assert (mpx < mpy) == (x < y)
+        assert (mpx > mpy) == (x > y)
+        assert (mpx == mpy) == (x == y)
+        assert (mpx != mpy) == (x != y)
+        assert (mpx <= mpy) == (x <= y)
+        assert (mpx >= mpy) == (x >= y)
+        assert mpx == mpx
+        assert mpx + mpy == x + y
+        assert mpx * mpy == x * y
+        assert mpx / mpy == x / y
+        assert abs(mpx) == abs(x)
+        assert mpf(repr(x)) == x
+
+def test_sqrt():
+    # this fails roughly 1 time out of 1000. it appers to be float
+    # that rounds the wrong way, not mpf
+    fail = 0
+    mpf.prec = 53
+    mpf.round_default()
+    for x in xs:
+        fail += (abs(mpf(x))**0.5 != abs(x)**0.5)
+    assert fail < 2*(N/1000.0)
+
+def test_bugs():
+    # particular bugs
+    assert mpf(4.4408920985006262E-16) < mpf(1.7763568394002505E-15)
+    assert mpf(-4.4408920985006262E-16) > mpf(-1.7763568394002505E-15)

mpmath-0.4/tests/test_convert.py

@@ -0,0 +1,62 @@
+import random
+from mpmath import *
+from mpmath.lib import *
+
+
+def test_basic_string():
+    """
+    Test basic string conversion
+    """
+    assert mpf('3') == mpf('3.0') == mpf('0003.') == mpf('0.03e2') == mpf(3.0)
+    assert mpf('30') == mpf('30.0') == mpf('00030.') == mpf(30.0)
+    for i in range(10):
+        for j in range(10):
+            assert mpf('%ie%i' % (i,j)) == i * 10**j
+    assert str(mpf('25000.0')) == '25000.0'
+    assert str(mpf('2500.0')) == '2500.0'
+    assert str(mpf('250.0')) == '250.0'
+    assert str(mpf('25.0')) == '25.0'
+    assert str(mpf('2.5')) == '2.5'
+    assert str(mpf('0.25')) == '0.25'
+    assert str(mpf('0.025')) == '0.025'
+    assert str(mpf('0.0025')) == '0.0025'
+    assert str(mpf('0.00025')) == '0.00025'
+    assert str(mpf('0.000025')) == '2.5e-5'
+    assert str(mpf(0)) == '0.0'
+    assert str(mpf('2.5e1000000000000000000000')) == '2.5e+1000000000000000000000'
+    assert str(mpf('2.6e-1000000000000000000000')) == '2.6e-1000000000000000000000'
+    assert str(mpf(1.23402834e-15)) == '1.23402834e-15'
+    assert str(mpf(-1.23402834e-15)) == '-1.23402834e-15'
+    assert str(mpf(-1.2344e-15)) == '-1.2344e-15'
+    assert repr(mpf(-1.2344e-15)) == "mpf('-1.2343999999999999e-15')"
+
+
+def test_tight_string_conversion():
+    # In an old version, '0.5' wasn't recognized as representing
+    # an exact binary number and was erroneously rounded up or down
+    assert from_str('0.5', 10, ROUND_FLOOR) == fhalf
+    assert from_str('0.5', 10, ROUND_CEILING) == fhalf
+
+
+def test_eval_repr_invariant():
+    """Test that eval(repr(x)) == x"""
+    random.seed(123)
+    for dps in [10, 15, 20, 50, 100]:
+        mpf.dps = dps
+        for i in xrange(1000):
+            a = mpf(random.random())**0.5 * 10**random.randint(-100, 100)
+            if dps == 15:
+                assert eval(repr(a)) == a
+            else:
+                assert eval(repr(a)).ae(a)
+
+def test_str_bugs():
+    # Decimal rounding used to give the wrong exponent in some cases
+    assert str(mpf('1e600')) == '1.0e+600'
+    assert str(mpf('1e10000')) == '1.0e+10000'
+
+
+def test_convert_rational():
+    assert from_rational(30, 5, 53, ROUND_HALF_EVEN) == (3, 1, 2)
+    assert from_rational(-7, 4, 53, ROUND_HALF_EVEN) == (-7, -2, 3)
+    assert to_rational((1, -1, 1)) == (1, 2)

mpmath-0.4/tests/test_division.py

@@ -0,0 +1,126 @@
+from mpmath.lib import *
+
+from random import randint, choice, seed
+
+all_modes = [ROUND_FLOOR, ROUND_CEILING, ROUND_DOWN, ROUND_UP,
+  ROUND_HALF_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN]
+
+fb = from_bstr
+fi = from_int_exact
+ff = from_float
+
+
+def test_div_1_3():
+    a = fi(1)
+    b = fi(3)
+    c = fi(-1)
+
+    # Floor rounds down, ceiling rounds up
+    assert fdiv(a, b, 7, ROUND_FLOOR)     == fb('0.01010101')
+    assert fdiv(a, b, 7, ROUND_CEILING)   == fb('0.01010110')
+    assert fdiv(a, b, 7, ROUND_DOWN)      == fb('0.01010101')
+    assert fdiv(a, b, 7, ROUND_UP)        == fb('0.01010110')
+    assert fdiv(a, b, 7, ROUND_HALF_DOWN) == fb('0.01010101')
+    assert fdiv(a, b, 7, ROUND_HALF_UP)   == fb('0.01010101')
+    assert fdiv(a, b, 7, ROUND_HALF_EVEN) == fb('0.01010101')
+
+    # Floor rounds up, ceiling rounds down
+    assert fdiv(c, b, 7, ROUND_FLOOR)     == fb('-0.01010110')
+    assert fdiv(c, b, 7, ROUND_CEILING)   == fb('-0.01010101')
+    assert fdiv(c, b, 7, ROUND_DOWN)      == fb('-0.01010101')
+    assert fdiv(c, b, 7, ROUND_UP)        == fb('-0.01010110')
+    assert fdiv(c, b, 7, ROUND_HALF_DOWN) == fb('-0.01010101')
+    assert fdiv(c, b, 7, ROUND_HALF_UP)   == fb('-0.01010101')
+    assert fdiv(c, b, 7, ROUND_HALF_EVEN) == fb('-0.01010101')
+
+
+def test_div_300():
+
+    q = fi(1000000)
+    a = fi(300499999)    # a/q is a little less than a half-integer
+    b = fi(300500000)    # b/q exactly a half-integer
+    c = fi(300500001)    # c/q is a little more than a half-integer
+
+    # Check nearest integer rounding (prec=9 as 2**8 < 300 < 2**9)
+
+    assert fdiv(a, q, 9, ROUND_DOWN) == fi(300)
+    assert fdiv(b, q, 9, ROUND_DOWN) == fi(300)
+    assert fdiv(c, q, 9, ROUND_DOWN) == fi(300)
+    assert fdiv(a, q, 9, ROUND_UP) == fi(301)
+    assert fdiv(b, q, 9, ROUND_UP) == fi(301)
+    assert fdiv(c, q, 9, ROUND_UP) == fi(301)
+    assert fdiv(a, q, 9, ROUND_HALF_UP) == fi(300)
+    assert fdiv(b, q, 9, ROUND_HALF_UP) == fi(301)
+    assert fdiv(c, q, 9, ROUND_HALF_UP) == fi(301)
+    assert fdiv(a, q, 9, ROUND_HALF_DOWN) == fi(300)
+    assert fdiv(b, q, 9, ROUND_HALF_DOWN) == fi(300)
+    assert fdiv(c, q, 9, ROUND_HALF_DOWN) == fi(301)
+
+    # Nearest even integer is down
+    assert fdiv(a, q, 9, ROUND_HALF_EVEN) == fi(300)
+    assert fdiv(b, q, 9, ROUND_HALF_EVEN) == fi(300)
+    assert fdiv(c, q, 9, ROUND_HALF_EVEN) == fi(301)
+
+    # Nearest even integer is up
+    a = fi(301499999)
+    b = fi(301500000)
+    c = fi(301500001)
+    assert fdiv(a, q, 9, ROUND_HALF_EVEN) == fi(301)
+    assert fdiv(b, q, 9, ROUND_HALF_EVEN) == fi(302)
+    assert fdiv(c, q, 9, ROUND_HALF_EVEN) == fi(302)
+
+
+def test_tight_integer_division():
+    # Test that integer division at tightest possible precision is exact
+    N = 100
+    seed(1)
+    for i in range(N):
+        a = choice([1, -1]) * randint(1, 1<<randint(10, 100))
+        b = choice([1, -1]) * randint(1, 1<<randint(10, 100))
+        p = a * b
+        width = bitcount(b) - trailing_zeros(b)
+        a = fi(a); b = fi(b); p = fi(p)
+        for mode in all_modes:
+            assert fdiv(p, a, width, mode) == b
+
+
+def test_epsilon_rounding():
+    # Verify that fdiv uses infinite precision; this result will
+    # appear to be exactly 0.101 to a near-sighted algorithm
+
+    a = fb('0.101' + ('0'*200) + '1')
+    b = fb('1.10101')
+    c = fmul(a, b, 250, ROUND_FLOOR) # Exact
+    assert fdiv(c, b, bitcount(a[0]), ROUND_FLOOR) == a # Exact
+
+    # Not exactly half, so both must round up
+    assert fdiv(c, b, 2, ROUND_HALF_DOWN) == fb('0.11')
+    assert fdiv(c, b, 2, ROUND_HALF_UP) == fb('0.11')
+
+    assert fdiv(c, b, 2, ROUND_DOWN) == fb('0.10')
+    assert fdiv(c, b, 3, ROUND_DOWN) == fb('0.101')
+    assert fdiv(c, b, 2, ROUND_UP) == fb('0.11')
+    assert fdiv(c, b, 3, ROUND_UP) == fb('0.110')
+    assert fdiv(c, b, 2, ROUND_FLOOR) == fb('0.10')
+    assert fdiv(c, b, 3, ROUND_FLOOR) == fb('0.101')
+    assert fdiv(c, b, 2, ROUND_CEILING) == fb('0.11')
+    assert fdiv(c, b, 3, ROUND_CEILING) == fb('0.110')
+
+    # The same for negative numbers
+    a = fb('-0.101' + ('0'*200) + '1')
+    b = fb('1.10101')
+    c = fmul(a, b, 250, ROUND_FLOOR)
+    assert fdiv(c, b, bitcount(a[0]), ROUND_FLOOR) == a
+
+    # Both must round away from zero
+    assert fdiv(c, b, 2, ROUND_HALF_DOWN) == fb('-0.11')
+    assert fdiv(c, b, 2, ROUND_HALF_UP) == fb('-0.11')
+
+    assert fdiv(c, b, 2, ROUND_DOWN) == fb('-0.10')
+    assert fdiv(c, b, 3, ROUND_UP) == fb('-0.110')
+
+    # Floor goes up, ceiling goes down
+    assert fdiv(c, b, 2, ROUND_FLOOR) == fb('-0.11')
+    assert fdiv(c, b, 3, ROUND_FLOOR) == fb('-0.110')
+    assert fdiv(c, b, 2, ROUND_CEILING) == fb('-0.10')
+    assert fdiv(c, b, 3, ROUND_CEILING) == fb('-0.101')

mpmath-0.4/tests/test_functions2.py

@@ -0,0 +1,68 @@
+import math
+from mpmath import *
+
+def test_incomplete_gamma():
+    mpf.dps = 15
+    assert upper_gamma(-2.5,-0.5).ae(-0.9453087204829418812-5.3164237738936178621j)
+    assert erf(0) == 0
+    assert erf(1).ae(0.84270079294971486934)
+    assert erf(3+4j).ae(-120.186991395079444098 - 27.750337293623902498j)
+    assert erf(-4-3j).ae(-0.99991066178539168236 + 0.00004972026054496604j)
+    assert erf(pi).ae(0.99999112385363235839)
+    assert erf(1j).ae(1.6504257587975428760j)
+    assert erf(-1j).ae(-1.6504257587975428760j)
+    assert isinstance(erf(1), mpf)
+    assert isinstance(erf(-1), mpf)
+    assert isinstance(erf(0), mpf)
+    assert isinstance(erf(0j), mpc)
+
+def test_gamma():
+    mpf.dps = 15
+    assert gamma(0.25).ae(3.6256099082219083119)
+    assert gamma(0.0001).ae(9999.4228832316241908)
+    assert gamma(300).ae('1.0201917073881354535e612')
+    assert gamma(-0.5).ae(-3.5449077018110320546)
+    assert gamma(-7.43).ae(0.00026524416464197007186)
+    #assert gamma(Rational(1,2)) == gamma(0.5)
+    #assert gamma(Rational(-7,3)).ae(gamma(mpf(-7)/3))
+    assert gamma(1+1j).ae(0.49801566811835604271 - 0.15494982830181068512j)
+    assert gamma(-1+0.01j).ae(-0.422733904013474115 + 99.985883082635367436j)
+    assert gamma(20+30j).ae(-1453876687.5534810 + 1163777777.8031573j)
+    # Should always give exact factorials when they can
+    # be represented as mpfs under the current working precision
+    fact = 1
+    for i in range(1, 18):
+        assert gamma(i) == fact
+        fact *= i
+    for dps in [170, 600]:
+        fact = 1
+        mpf.dps = dps
+        for i in range(1, 105):
+            assert gamma(i) == fact
+            fact *= i
+    mpf.dps = 100
+    assert gamma(0.5).ae(sqrt(pi))
+    mpf.dps = 15
+    assert factorial(0) == 1
+    assert factorial(3) == 6
+
+def test_zeta():
+    mpf.dps = 15
+    assert zeta(2).ae(pi**2 / 6)
+    assert zeta(2.0).ae(pi**2 / 6)
+    assert zeta(mpc(2)).ae(pi**2 / 6)
+    assert zeta(100).ae(1)
+    assert zeta(0).ae(-0.5)
+    assert zeta(0.5).ae(-1.46035450880958681)
+    assert zeta(-1).ae(-mpf(1)/12)
+    assert zeta(-2).ae(0)
+    assert zeta(-3).ae(mpf(1)/120)
+    assert zeta(-4).ae(0)
+    # Zeros in the critical strip
+    assert zeta(mpc(0.5, 14.1347251417346937904)).ae(0)
+    assert zeta(mpc(0.5, 21.0220396387715549926)).ae(0)
+    assert zeta(mpc(0.5, 25.0108575801456887632)).ae(0)
+    mpf.dps = 50
+    im = '236.5242296658162058024755079556629786895294952121891237'
+    assert zeta(mpc(0.5, im)).ae(0, 1e-46)
+    mpf.dps = 15