mpmath 0.3__zip → 0.4__zip

mpmath-0.4/mpmath/lib/util.py

@@ -0,0 +1,268 @@
+"""
+Contents of this module:
+
+* Integer and bit-level operations
+* Miscellaneous utilities
+
+"""
+
+import math
+import decimal
+
+# Same as standard Python float
+STANDARD_PREC = 53
+
+LOG2_10 = math.log(10,2)  # 3.3219...
+
+
+# All supported rounding modes. We define them as integer constants for easy
+# management, but change __repr__ to give more information on inspection
+
+class Rounding(int):
+
+    def __new__(cls, level, name):
+        a = int.__new__(cls, level)
+        a.name = name
+        return a
+
+    def __repr__(self):
+        return self.name
+
+    __str__ = __repr__
+
+ROUND_DOWN    = Rounding(1, 'ROUND_DOWN')
+ROUND_UP      = Rounding(2, 'ROUND_UP')
+ROUND_FLOOR   = Rounding(3, 'ROUND_FLOOR')
+ROUND_CEILING = Rounding(4, 'ROUND_CEILING')
+ROUND_HALF_UP = Rounding(5, 'ROUND_HALF_UP')
+ROUND_HALF_DOWN = Rounding(6, 'ROUND_HALF_DOWN')
+ROUND_HALF_EVEN = Rounding(7, 'ROUND_HALF_EVEN')
+
+
+def giant_steps(start, target):
+    """Generate a list of precisions ranging from 'start' to 'target'
+    that doubles with each step. This is used by quadratically
+    convergent iterations (that is, Newton iterations), where we want
+    to keep the precision at the same level as the accuracy in each
+    step to minimize work.
+
+    For example, to find a sequence of precisions to reach 1000 bits
+    starting from a 53-bit estimate, giant_steps(53, 1000) gives
+
+        [64, 126, 251, 501, 1000]
+
+    So, if we start Newton's method with a 53-bit accurate initial
+    guess, the first iteration should be carried out at 64-bit
+    precision, the second at 126-bit precision, and so on.
+
+    Note the conservative rounding (1000 to 501, etc); this is used
+    guard against unit errors in the last place."""
+    L = [target]
+    while L[-1] > start*2:
+        L = L + [L[-1]//2 + 1]
+    return L[::-1]
+
+
+def rshift_quick(x, n):
+    """For an integer x, calculate x >> n with the fastest (floor)
+    rounding. Unlike the plain Python expression (x >> n), n is
+    allowed to be negative, in which case a left shift is performed."""
+    if n >= 0: return x >> n
+    else:      return x << (-n)
+
+
+def lshift_quick(x, n):
+    """For an integer x, calculate x << n. Unlike the plain Python
+    expression (x << n), n is allowed to be negative, in which case a
+    right shift with default (floor) rounding is performed."""
+    if n >= 0: return x << n
+    else:      return x >> (-n)
+
+
+def make_fixed(s, prec):
+    """Convert a floating-point number to a fixed-point big integer"""
+    man, exp, bc = s
+    offset = exp + prec
+    if offset >= 0:
+        return man << offset
+    else:
+        return man >> (-offset)
+
+
+def bitcount(n, log=math.log, table=(0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4)):
+    """Give size of n in bits; i.e. the position of the highest set bit
+    in n. If n is negative, the absolute value is used. The bitcount of
+    zero is taken to be 0."""
+
+    if not n: return 0
+    if n < 0: n = -n
+
+    # math.log gives a good estimate, and never overflows, but
+    # is not always exact. Subtract 2 to underestimate, then
+    # count remaining bits by table lookup
+    bc = int(log(n, 2)) - 2
+    if bc < 0:
+        bc = 0
+    return bc + table[n >> bc]
+
+
+# from decimal.py -- faster for small precs
+def bitcount2(n, correction = {
+        '0': 4, '1': 3, '2': 2, '3': 2,
+        '4': 1, '5': 1, '6': 1, '7': 1,
+        '8': 0, '9': 0, 'a': 0, 'b': 0,
+        'c': 0, 'd': 0, 'e': 0, 'f': 0}):
+    if n < 0:
+        n = -n
+    hex_n = "%x" % n
+    return 4*len(hex_n) - correction[hex_n[0]]
+
+
+def trailing_zeros(n):
+    """Count trailing zero bits in an integer. If n is negative, it is
+    replaced by its absolute value."""
+    if n & 1: return 0
+    if not n: return 0
+    if n < 0: n = -n
+    t = 0
+    while not n & 0xffffffffffffffff: n >>= 64; t += 64
+    while not n & 0xff: n >>= 8; t += 8
+    while not n & 1: n >>= 1; t += 1
+    return t
+
+#----------------------------------------------------------------------------
+# Integer shifting with directed rounding
+#
+
+def round_floor(x, n):
+    if not n or not x: return x
+    if n < 0: return x << -n
+    return x >> n
+
+def round_ceiling(x, n):
+    if not n or not x: return x
+    if n < 0: return x << -n
+    return -((-x) >> n)
+
+def round_down(x, n):
+    if not n or not x: return x
+    if n < 0: return x << -n
+    if x > 0:
+        return x >> n
+    else:
+        return -((-x) >> n)
+
+def round_up(x, n):
+    if not n or not x: return x
+    if n < 0: return x << -n
+    if x > 0:
+        return -((-x) >> n)
+    else:
+        return x >> n
+
+def round_half_up(x, n):
+    if not n or not x: return x
+    if n < 0: return x << -n
+    positive = x > 0
+    if positive: t = x >> (n-1)
+    else:        t = (-x) >> (n-1)
+    if t & 1:
+        if positive: return (t>>1)+1
+        else:        return -((t>>1)+1)
+    if positive: return t>>1
+    else:        return -(t>>1)
+
+def round_half_down(x, n):
+    if not n or not x: return x
+    if n < 0: return x << -n
+    positive = x > 0
+    if positive: t = x >> (n-1)
+    else:        t = (-x) >> (n-1)
+    if t & 1 and x & ((1<<(n-1))-1):
+        if positive: return (t>>1)+1
+        else:        return -((t>>1)+1)
+    if positive: return t>>1
+    else:        return -(t>>1)
+
+def round_half_even(x, n):
+    if not n or not x: return x
+    if n < 0: return x << -n
+    positive = x > 0
+    if positive: t = x >> (n-1)
+    else:        t = (-x) >> (n-1)
+    if t & 1 and (t&2 or x & ((1<<(n-1))-1)):
+        if positive: return (t>>1)+1
+        else:        return -((t>>1)+1)
+    if positive:  return t>>1
+    else:         return -(t>>1)
+
+
+rounding_functions = {
+  ROUND_FLOOR : round_floor,
+  ROUND_CEILING : round_ceiling,
+  ROUND_DOWN : round_down,
+  ROUND_UP : round_up,
+  ROUND_HALF_UP : round_half_up,
+  ROUND_HALF_DOWN : round_half_down,
+  ROUND_HALF_EVEN : round_half_even
+}
+
+
+def rshift(x, n, rounding):
+    """Shift x (a plain Python integer) n bits to the right (i.e.,
+    calculate x/(2**n)), and round to the nearest integer in accordance
+    with the specified rounding mode. The exponent n may be negative,
+    in which case x is shifted to the left (and no rounding is
+    necessary)."""
+    return rounding_functions[rounding](x, n)
+
+
+
+# TODO: speed up for bases 2, 4, 8, 16, ...
+
+def bin_to_radix(x, xbits, base, bdigits):
+    """
+    Radix conversion for fixed-point numbers. That is, convert
+    x * 2**xbits to floor(x * 10**bdigits).
+    """
+    return x * (base**bdigits) >> xbits
+
+stddigits = '0123456789abcdefghijklmnopqrstuvwxyz'
+
+def small_numeral(n, base=10, digits=stddigits):
+    """
+    Return the string numeral of a positive integer in an arbitrary
+    base. Most efficient for small input.
+    """
+    if base == 10:
+        return str(n)
+    digs = []
+    while n:
+        n, digit = divmod(n, base)
+        digs.append(digits[digit])
+    return "".join(digs[::-1])
+
+def numeral(n, base=10, size=0, digits=stddigits):
+    """
+    Represent the integer n as a string of digits in the given base.
+    Recursive division is used to make this function about 3x faster
+    than Python's str() for converting integers to decimal strings.
+
+    The 'size' parameters specifies the number of digits in n; this
+    number is only used to determine splitting points and need not
+    be exact.
+    """
+
+    if n < 0:
+        return "-" + numeral(-n, base, size, digits)
+
+    # Fast enough to do directly
+    if size < 250:
+        return small_numeral(n, base, digits)
+
+    # Divide in half
+    half = (size // 2) + (size & 1)
+    A, B = divmod(n, base**half)
+    ad = numeral(A, base, half, digits)
+    bd = numeral(B, base, half, digits).rjust(half, "0")
+    return ad + bd

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

@@ -1,17 +1,44 @@
 from lib import *
 from decimal import Decimal
 
+
 class mpnumeric(object):
     """Base class for mpf and mpc. Calling mpnumeric(x) returns an mpf
     if x can be converted to an mpf (if it is a float, int, mpf, ...),
     and an mpc if x is complex."""
+
     def __new__(cls, val):
+        # TODO: should maybe normalize here
         if isinstance(val, cls):
             return val
         if isinstance(val, complex):
             return mpc(val)
         return mpf(val)
 
+def convert_lossless(x):
+    """Attempt to convert x to an mpf or mpc losslessly. If x is an
+    mpf or mpc, return it unchanged. If x is an int, create an mpf with
+    sufficient precision to represent it exactly.
+
+    If x is a decimal or str, just convert it to an mpf with the
+    current working precision (perhaps this should be done
+    differently...)"""
+    if isinstance(x, mpnumeric):
+        return x
+    if isinstance(x, float):
+        return make_mpf(from_float(x, 53, ROUND_FLOOR))
+    if isinstance(x, int_types):
+        return make_mpf(from_int(x, bitcount(x), ROUND_FLOOR))
+    if isinstance(x, complex):
+        return mpc(x)
+    if isinstance(x, (Decimal, str)):
+        if x == 'inf': return inf
+        if x == '-inf': return minus_inf
+        if x == 'nan': return nan
+        return make_mpf(from_str(x, mpf._prec, mpf._rounding))
+    raise TypeError("cannot create mpf from " + repr(x))
+
+
 class context(type):
     """Metaclass for mpf and mpc. Holds global working precision."""
 
@@ -44,14 +71,15 @@ class context(type):
 
 int_types = (int, long)
 
+
 def _convert(x):
     """Convet x to mpf data"""
     if isinstance(x, float):
-        return float_from_pyfloat(x, mpf._prec, mpf._rounding)
+        return from_float(x, mpf._prec, mpf._rounding)
     if isinstance(x, int_types):
-        return float_from_int(x, mpf._prec, mpf._rounding)
+        return from_int(x, mpf._prec, mpf._rounding)
     if isinstance(x, (Decimal, str)):
-        return decimal_to_binary(x, mpf._prec, mpf._rounding)
+        return from_str(x, mpf._prec, mpf._rounding)
     raise TypeError("cannot create mpf from " + repr(x))
 
 
@@ -93,7 +121,7 @@ class mpf(mpnumeric):
         """A new mpf can be created from a Python float, an int, a
         Decimal, or a decimal string representing a number in
         floating-point format. Examples:
-        
+
             mpf(25)
             mpf(2.5)
             mpf('2.5')
@@ -120,10 +148,10 @@ class mpf(mpnumeric):
 
     def __repr__(s):
         st = "mpf('%s')"
-        return st % binary_to_decimal(s.val, mpf._dps+2)
+        return st % to_str(s.val, mpf._dps+2)
 
     def __str__(s):
-        return binary_to_decimal(s.val, mpf._dps)
+        return to_str(s.val, mpf._dps)
 
     def __hash__(s):
         try:
@@ -136,14 +164,17 @@ class mpf(mpnumeric):
             return hash(self.val)
 
     def __int__(s):
-        return float_to_int(s.val)
+        return to_int(s.val)
 
     def __float__(s):
-        return float_to_pyfloat(s.val)
+        return to_float(s.val)
 
     def __complex__(s):
         return float(s) + 0j
 
+    def __nonzero__(s):
+        return bool(s.man)
+
     def __eq__(s, t):
         if not isinstance(t, mpf):
             if isinstance(t, complex_types):
@@ -256,7 +287,7 @@ class mpf(mpnumeric):
         return power(s, t)
 
     def __rpow__(s, t):
-        return mpnumeric(t) ** s
+        return convert_lossless(t) ** s
 
     def sqrt(s):
         return sqrt(s)
@@ -307,7 +338,6 @@ def make_mpf(tpl, construct=object.__new__, cls=mpf):
     return a
 
 
-
 class mpc(mpnumeric):
     """An mpc represents a complex number using a pair of mpf:s (one
     for the real part and another for the imaginary part.) The mpc
@@ -380,11 +410,8 @@ class mpc(mpnumeric):
     def __mul__(s, t):
         if not isinstance(t, mpc):
             t = mpc(t)
-        a = s.real; b = s.imag; c = t.real; d = t.imag
-        if b == d == 0:
-            return mpc(a*c, 0)
-        else:
-            return mpc(a*c-b*d, a*d+b*c)
+        return mpc(*fcmul(s.real.val, s.imag.val, t.real.val, t.imag.val,
+            mpf._prec, mpf._rounding))
 
     __rmul__ = __mul__
 
@@ -418,7 +445,7 @@ class mpc(mpnumeric):
         return power(s, n)
 
     def __rpow__(s, t):
-        return mpnumeric(t) ** s
+        return convert_lossless(t) ** s
 
     # TODO: refactor and merge with mpf.ae
     def ae(s, t, rel_eps=None, abs_eps=None):
@@ -472,7 +499,10 @@ class constant(mpf):
     #    return "<%s: %s~>" % (self.name, mpf.__str__(self))
 
 
+_180 = from_int(180, 10, ROUND_FLOOR)
+
 pi = constant(fpi, "pi")
+degree = constant(lambda p, r: fdiv(fpi(p+4, ROUND_FLOOR), _180, p, r), "degree")
 e = constant(lambda p, r: fexp(fone, p, r), "e")
 cgamma = constant(fgamma, "Euler's constant gamma")
 clog2 = constant(flog2, "log(2)")
@@ -483,7 +513,7 @@ def sqrt(x):
     """For real x >= 0, returns the square root of x. For negative or
     complex x, returns the principal branch of the complex square root
     of x."""
-    x = mpnumeric(x)
+    x = convert_lossless(x)
     if isinstance(x, mpf) and x.val[0] >= 0:
         return make_mpf(fsqrt(x.val, mpf._prec, mpf._rounding))
     x = mpc(x)
@@ -500,7 +530,7 @@ def hypot(x, y):
 # can construct all of them the same way (unlike log, sqrt, etc)
 def ef(name, real_f, complex_f, doc):
     def f(x):
-        x = mpnumeric(x)
+        x = convert_lossless(x)
         if isinstance(x, mpf):
             return make_mpf(real_f(x.val, mpf._prec, mpf._rounding))
         else:
@@ -519,7 +549,7 @@ sinh = ef('sinh', fsinh, fcsinh, "Returns the hyperbolic sine of x.")
 # TODO: implement tanh and complex tan in lib instead
 def tan(x):
     """Returns the tangent of x."""
-    x = mpnumeric(x)
+    x = convert_lossless(x)
     if isinstance(x, mpf):
         return make_mpf(ftan(x.val, mpf._prec, mpf._rounding))
     # the complex division can cause enormous cancellation.
@@ -531,7 +561,7 @@ def tan(x):
 
 def tanh(x):
     """Returns the hyperbolic tangent of x."""
-    x = mpnumeric(x)
+    x = convert_lossless(x)
     oldprec = mpf._prec
     a = abs(x)
     mpf._prec += 10
@@ -569,7 +599,7 @@ def log(x, b=None):
         a = log(x) / log(b)
         mpf.prec -= 3
         return +a
-    x = mpnumeric(x)
+    x = convert_lossless(x)
     if not x:
         raise ValueError, "logarithm of 0"
     if isinstance(x, mpf) and x.val[0] > 0:
@@ -587,7 +617,7 @@ def power(x, y):
 
 def atan(x):
     """Returns the inverse tangent of x."""
-    x = mpnumeric(x)
+    x = convert_lossless(x)
     if isinstance(x, mpf):
         return make_mpf(fatan(x.val, mpf._prec, mpf._rounding))
     # TODO: maybe get this to agree with Python's cmath atan about the
@@ -631,10 +661,8 @@ def _asin_complex(z):
 def asin(x):
     """Returns the inverse sine of x. Outside the range [-1, 1], the
     result is complex and defined as the principal branch value of
-
-        -i * log(i * x + sqrt(1 - x**2)).
-    """
-    x = mpnumeric(x)
+    -i * log(i * x + sqrt(1 - x**2))."""
+    x = convert_lossless(x)
     if isinstance(x, mpf) and abs(x) <= 1:
         return _asin_complex(x).real
     return _asin_complex(x)
@@ -648,21 +676,16 @@ def _acos_complex(z):
 def acos(x):
     """Returns the inverse cosine of x. Outside the range [-1, 1], the
     result is complex and defined as the principal branch value of
-
-        pi/2 + i * log(i * x + sqrt(1 - x**2)).
-    """
-    x = mpnumeric(x)
+    pi/2 + i * log(i * x + sqrt(1 - x**2))."""
+    x = convert_lossless(x)
     if isinstance(x, mpf) and abs(x) <= 1:
         return _acos_complex(x).real
     return _acos_complex(x)
 
 def asinh(x):
     """Returns the inverse hyperbolic sine of x. For complex x, the
-    result is the principal branch value of
-    
-        log(x + sqrt(1 + x**2)).
-    """
-    x = mpnumeric(x)
+    result is the principal branch value of log(x + sqrt(1 + x**2))."""
+    x = convert_lossless(x)
     oldprec = mpf._prec
     a = abs(x)
     mpf._prec += 10
@@ -679,7 +702,7 @@ def acosh(x):
     """Returns the inverse hyperbolic cosine of x. The value is
     given by log(x + sqrt(1 + x**2)), where the principal branch is
     used when the result is complex."""
-    x = mpnumeric(x)
+    x = convert_lossless(x)
     mpf._prec += 10
     t = log(x + sqrt(x-1)*sqrt(x+1))
     mpf._prec -= 10
@@ -688,11 +711,8 @@ def acosh(x):
 def atanh(x):
     """Returns the inverse hyperbolic tangent of x. Outside the range
     [-1, 1], the result is complex and defined as the principal branch
-    value of
-
-        (log(1+x) - log(1-x))/2.
-    """
-    x = mpnumeric(x)
+    value of (log(1+x) - log(1-x))/2."""
+    x = convert_lossless(x)
     oldprec = mpf._prec
     a = abs(x)
     mpf._prec += 10
@@ -706,8 +726,14 @@ def atanh(x):
     mpf._prec = oldprec
     return +t
 
+def rand():
+    """Return an mpf chosen randomly from [0, 1)."""
+    return make_mpf(frand(mpf._prec))
+
+
+__all__ = ["mpnumeric", "mpf", "mpc", "pi", "e", "cgamma", "clog2", "clog10",
+  "j", "sqrt", "hypot", "exp", "log", "cos", "sin", "tan", "atan", "atan2",
+  "power", "asin", "acos", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh",
+  "arg", "degree", "rand"]
 
-__all__ = ["mpnumeric", "mpf", "mpc", "pi", "e", "cgamma", "clog2", "clog10", "j",
-  "sqrt", "hypot", "exp", "log", "cos", "sin", "tan", "atan", "atan2", "power",
-  "asin", "acos", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "arg"]
 

{mpmath-0.3 → 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.3',
+      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
+