snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/verify/{squareExtensions.py → square_extensions.py}

@@ -1,5 +1,5 @@
 """
-The squareExtensions module provides
+The square_extensions module provides
 two special classes to give exact representations of the values
 involved when computing a cusp cross section.
 
@@ -18,6 +18,7 @@ implementation of the == operator.
 
 import operator
 from functools import reduce
+from ..math_basics import prod
 from ..sage_helper import _within_sage, sage_method, SageNotAvailable
 
 __all__ = ['find_shapes_as_complex_sqrt_lin_combinations',
@@ -38,7 +39,8 @@ if _within_sage:
 
     from ..snap import find_field
 
-from .realAlgebra import field_containing_real_and_imaginary_part_of_number_field
+from .real_algebra import field_containing_real_and_imaginary_part_of_number_field
+
 
 def eval_number_field_elt(elt, root):
     # SageMath 7.6 can no longer evaluate a rational polynomial on an
@@ -72,12 +74,13 @@ def eval_number_field_elt(elt, root):
 # This is implemented in
 #    _field_containing_real_and_imaginary_part_of_algebraic_number_LLL.
 # This was still very slow and failed on t11669 and 9 manifolds with 9 tetrahedra.
-# 
-# The fastest implementation so far is in realAlgebra. The implementation there
+#
+# The fastest implementation so far is in real_algebra. The implementation there
 # turns the one complex equation p(z) = 0 defining the number field into two
 # real equations for the real and imaginary part of the complex equation and
 # then uses the resultant to find exact solutions.
 
+
 @sage_method
 def find_shapes_as_complex_sqrt_lin_combinations(M, prec, degree):
     """
@@ -108,7 +111,7 @@ def find_shapes_as_complex_sqrt_lin_combinations(M, prec, degree):
     # exact_complex_shapes are elements in a Sage NumberField
     complex_number_field, complex_root, exact_complex_shapes = complex_data
 
-    # We now have a generator (complex_root) for the NumberField 
+    # We now have a generator (complex_root) for the NumberField
     # containing the shapes.
     # Next, we need to find the NumberField containing the real and imaginary
     # part of this generator.
@@ -121,7 +124,7 @@ def find_shapes_as_complex_sqrt_lin_combinations(M, prec, degree):
 
     real_number_field, real_part, imag_part = real_result
 
-    # Caches the values of 
+    # Caches the values of
     #      nf.gen_embedding()
     # and  RealIntervalField(prec)(nf.gen_embedding())
     # for different precision prec where nf is the NumberField real_number_field
@@ -130,17 +133,18 @@ def find_shapes_as_complex_sqrt_lin_combinations(M, prec, degree):
     # This is for speed only. See _get_interval_embedding_from_cache for
     # details.
     embed_cache = {}
-    
+
     # The generator of the shape field as the desired return type
     exact_complex_root = ComplexSqrtLinCombination(real_part, imag_part,
-                                                   embed_cache = embed_cache)
+                                                   embed_cache=embed_cache)
 
     # All shapes are given as polynomials in the generator,
     # so translate them to be of the desired return type
     return [ eval_number_field_elt(exact_complex_shape, exact_complex_root)
              for exact_complex_shape in exact_complex_shapes ]
 
-class SqrtLinCombination(object):
+
+class SqrtLinCombination():
     """
     A class representing a linear combination
 
@@ -179,7 +183,7 @@ class SqrtLinCombination(object):
     cancel the two sqrt's and apply the common r_{i,j} to the c_i of the result
     instead. Thus, the following procedure for determining whether D == 0 will
     eventually terminate:
-    
+
     - if the number of terms n is 0, return True
     - if the number of terms n is 1, return c_1 == 0
     - if there is a r_{i,j} common to each summand, factor it out
@@ -240,17 +244,16 @@ class SqrtLinCombination(object):
 
     """
 
-    def __init__(self, value = None, d = {}, embed_cache = None):
+    def __init__(self, value=None, d={}, embed_cache=None):
         # Initialize from either a value or a dictionary
-        
+
         #    c_1 * sqrt(r_1) + c_2 * sqrt(r_2) + ... + c_n * sqrt(r_n)
         #
         # is encoded as dictionary
         #
         #   { r_1 : c_1, r_2 : c_2, ..., r_n : c_n }
 
-
-        if not value is None:
+        if value is not None:
             if d:
                 raise TypeError("SqrtLinCombination has both value and "
                                 "dictionary.")
@@ -265,15 +268,18 @@ class SqrtLinCombination(object):
         else:
             # Filter out zero elements
             self._dict = _filter_zero(d)
-            
+
         # Set embed cache, see _get_interval_embedding_from_cache for details
         self._embed_cache = embed_cache
 
+    def parent(self):
+        return SqrtLinCombination
+        
     def __add__(self, other):
         # Try to convert other term to SqrtLinCombination if necessary
         if not isinstance(other, SqrtLinCombination):
             return self + SqrtLinCombination(
-                other, embed_cache = _get_embed_cache(self, other))
+                other, embed_cache=_get_embed_cache(self, other))
 
         # Add
         d = {}
@@ -282,14 +288,14 @@ class SqrtLinCombination(object):
         for k, v in other._dict.items():
             d[k] = d.get(k, 0) + v
         return SqrtLinCombination(
-            d = d,
-            embed_cache = _get_embed_cache(self, other))
+            d=d,
+            embed_cache=_get_embed_cache(self, other))
 
     def __neg__(self):
         # Negate
         return SqrtLinCombination(
-            d = dict( (k, -v) for k, v in self._dict.items() ),
-            embed_cache = self._embed_cache)
+            d={ k: -v for k, v in self._dict.items() },
+            embed_cache=self._embed_cache)
 
     def __sub__(self, other):
         # Subtract
@@ -300,7 +306,7 @@ class SqrtLinCombination(object):
         if not isinstance(other, SqrtLinCombination):
             return self * SqrtLinCombination(
                 other,
-                embed_cache = _get_embed_cache(self, other))
+                embed_cache=_get_embed_cache(self, other))
 
         # Result
         d = {}
@@ -324,13 +330,13 @@ class SqrtLinCombination(object):
                     m = k1 * k2
                     d[m] = d.get(m, 0) + p
         return SqrtLinCombination(
-            d = d, embed_cache = _get_embed_cache(self, other))
+            d=d, embed_cache=_get_embed_cache(self, other))
 
     def inverse(self):
         # The inverse element of                c_1 * sqrt(r_1)
         #                     is  (1 / (c_1 * r_1)) * sqrt(r_1)
         l = len(self._dict)
-        if not l == 1:
+        if l != 1:
             # Do not implement other elements.
             if l == 0:
                 # In particular, do not invert 0
@@ -340,15 +346,15 @@ class SqrtLinCombination(object):
 
         # Iteration over the only term
         for k, v in self._dict.items():
-            return SqrtLinCombination( 
-                d = { k : 1 / (v * k) },
-                embed_cache = self._embed_cache)
+            return SqrtLinCombination(
+                d={ k : 1 / (v * k) },
+                embed_cache=self._embed_cache)
 
     def __div__(self, other):
         # Try to convert other term to SqrtLinCombination if necessary
         if not isinstance(other, SqrtLinCombination):
             return self / SqrtLinCombination(
-                other, embed_cache = _get_embed_cache(self, other))
+                other, embed_cache=_get_embed_cache(self, other))
         return self * other.inverse()
 
     def __truediv__(self, other):
@@ -375,17 +381,17 @@ class SqrtLinCombination(object):
         if l == 0:
             # sqrt of 0
             return SqrtLinCombination(
-                embed_cache = self._embed_cache)
+                embed_cache=self._embed_cache)
         if l == 1:
             # Iterate through only term
             for k, v in self._dict.items():
                 # Make sure expression in sqrt is 1
-                if not k == 1:
+                if k != 1:
                     raise TypeError('SqrtLinCombination sqrt not fully '
                                     'implemented')
                 return SqrtLinCombination(
-                    d = { v: _One},
-                    embed_cache = self._embed_cache)
+                    d={ v: _One},
+                    embed_cache=self._embed_cache)
         raise TypeError('SqrtLinCombination sqrt not fully implemented')
 
     def __repr__(self):
@@ -416,7 +422,6 @@ class SqrtLinCombination(object):
 
     def __ge__(self, other):
         raise Exception('Not implemented')
-        
 
     def _real_mpfi_(self, RIF):
         """
@@ -473,7 +478,7 @@ class SqrtLinCombination(object):
         # be slow so we try numerically first.
         prec = 106
         numerical_sign, interval_val = self._sign_numerical(prec)
-        if not numerical_sign is None:
+        if numerical_sign is not None:
             # We could determine the sign using interval arithmetics
             # Return the result.
             return numerical_sign, interval_val
@@ -488,7 +493,7 @@ class SqrtLinCombination(object):
         while True:
             prec *= 2
             numerical_sign, interval_val = self._sign_numerical(prec)
-            if not numerical_sign is None:
+            if numerical_sign is not None:
                 return numerical_sign, interval_val
 
     def sign(self):
@@ -500,27 +505,27 @@ class SqrtLinCombination(object):
         return self.sign_with_interval()[0]
 
 
-class ComplexSqrtLinCombination(object):
+class ComplexSqrtLinCombination():
     """
     A pair (real, imag) of SqrtLinCombinations representing the complex number
     real + imag * I. Supports ``real()``, ``imag()``, ``+``, ``-``, ``*``, ``/``,
     ``abs``, ``conjugate()`` and ``==``.
     """
 
-    def __init__(self, real, imag = 0, embed_cache = None):
+    def __init__(self, real, imag=0, embed_cache=None):
         if isinstance(real, SqrtLinCombination):
             self._real = real
         else:
             self._real = SqrtLinCombination(
                 real,
-                embed_cache = embed_cache)
+                embed_cache=embed_cache)
 
         if isinstance(imag, SqrtLinCombination):
             self._imag = imag
         else:
             self._imag = SqrtLinCombination(
                 imag,
-                embed_cache = embed_cache)
+                embed_cache=embed_cache)
 
     def __repr__(self):
         return "ComplexSqrtLinCombination(%r, %r)" % (self._real, self._imag)
@@ -547,7 +552,7 @@ class ComplexSqrtLinCombination(object):
     def __add__(self, other):
         if not isinstance(other, ComplexSqrtLinCombination):
             return self + ComplexSqrtLinCombination(other)
-        
+
         return ComplexSqrtLinCombination(self._real + other._real,
                                          self._imag + other._imag)
 
@@ -604,7 +609,7 @@ class ComplexSqrtLinCombination(object):
 
     def __ne__(self, other):
         return not (self == other)
-        
+
     def __lt__(self, other):
         raise TypeError('No order on complex numbers.')
 
@@ -627,11 +632,13 @@ class ComplexSqrtLinCombination(object):
         # And just pair
         return CIF(RIF(self._real), RIF(self._imag))
 
+
 class _SqrtException(Exception):
     pass
 
-class _FactorizedSqrtLinCombination(object):
-    def __init__(self, d = {}, embed_cache = None):
+
+class _FactorizedSqrtLinCombination():
+    def __init__(self, d={}, embed_cache=None):
         #       c_1 * sqrt(r_{1,1}) * sqrt(r_{1,2}) * ... * sqrt(r_{1,k_1})
         #     + c_2 * sqrt(r_{2,1}) * sqrt(r_{2,2}) * ... * sqrt(r_{2,k_2})
         #     + ...
@@ -652,23 +659,21 @@ class _FactorizedSqrtLinCombination(object):
     def _real_mpfi_(self, RIF):
 
         def eval_term(k, v):
-            # Evaluate one term 
+            # Evaluate one term
             # c_i * sqrt(r_{i,1}) * sqrt(r_{i,2}) * ... * sqrt(r_{i,k_2})
             # where c_i is stored in v
             # and k is the set of r_{i,j}
-            
+
             # Take the product of all r_{i,j} after converting to intervals
-            prod = reduce(
-                operator.mul,
-                [_to_RIF(t, RIF, self._embed_cache) for t in k],
-                RIF(1))
+            pr = prod([_to_RIF(t, RIF, self._embed_cache) for t in k],
+                      RIF(1))
 
             # Raise exception if interval isn't positive
-            if not prod > 0:
+            if not pr > 0:
                 raise _SqrtException()
 
             # Return interval for term
-            return prod.sqrt() * _to_RIF(v, RIF, self._embed_cache)
+            return pr.sqrt() * _to_RIF(v, RIF, self._embed_cache)
 
         # Sum over all terms
         return sum([eval_term(k, v) for k, v in self._dict.items()], RIF(0))
@@ -699,9 +704,9 @@ class _FactorizedSqrtLinCombination(object):
             else:
                 return frozenset([k])
 
-        return _FactorizedSqrtLinCombination(dict(
-            (to_set(k), v) for k, v in l._dict.items()),
-            embed_cache = l._embed_cache)
+        return _FactorizedSqrtLinCombination({
+            to_set(k): v for k, v in l._dict.items()},
+            embed_cache=l._embed_cache)
 
     def __add__(self, other):
         # Add
@@ -712,12 +717,12 @@ class _FactorizedSqrtLinCombination(object):
             d[k] = d.get(k, 0) + v
         return _FactorizedSqrtLinCombination(
             d,
-            embed_cache = _get_embed_cache(self, other))
+            embed_cache=_get_embed_cache(self, other))
 
     def __neg__(self):
         return _FactorizedSqrtLinCombination(
-            dict((k, -v) for k, v in self._dict.items()),
-            embed_cache = self._embed_cache)
+            {k: -v for k, v in self._dict.items()},
+            embed_cache=self._embed_cache)
 
     def __sub__(self, other):
         return self + (-other)
@@ -734,22 +739,22 @@ class _FactorizedSqrtLinCombination(object):
                 #
                 # If sqrt(r) appears in both terms, it becomes
                 # sqrt(r) * sqrt(r) = r and is multiplied into the coefficient
-                # (this is done by _prod(k1 & k2)).
+                # (this is done by prod(k1 & k2), _One).
                 # A sqrt(r) appearing only appearing in one term survives
                 # (k1^k2)
 
                 k = k1 ^ k2
-                v = v1 * v2 * _prod(k1 & k2)
+                v = v1 * v2 * prod(k1 & k2, _One)
                 d[k] = d.get(k, 0) + v
         return _FactorizedSqrtLinCombination(
-            d, embed_cache = _get_embed_cache(self, other))
+            d, embed_cache=_get_embed_cache(self, other))
 
     def is_zero(self):
         """
         Returns True if it is zero, False otherwise.
         """
 
-        # Implements the algorithm for operator == described in 
+        # Implements the algorithm for operator == described in
         # SqrtLinCombination
 
         # The case of no terms n = 0
@@ -765,18 +770,18 @@ class _FactorizedSqrtLinCombination(object):
             operator.and_, self._dict.keys())
 
         # Factor them out
-        d = dict((k - common_terms, v) for k, v in self._dict.items())
+        d = {k - common_terms: v for k, v in self._dict.items()}
 
         # Pick one r_{i,j}
         term = _firstfirst(d.keys())
-        
+
         # Split the summands into "left" and "right"
         left = _FactorizedSqrtLinCombination(
-            dict( (k, v) for k, v in d.items() if term in k ),
-            embed_cache = self._embed_cache)
+            { k: v for k, v in d.items() if term in k },
+            embed_cache=self._embed_cache)
         right = _FactorizedSqrtLinCombination(
-            dict( (k, v) for k, v in d.items() if not term in k),
-            embed_cache = self._embed_cache)
+            { k: v for k, v in d.items() if term not in k},
+            embed_cache=self._embed_cache)
 
         # Check left^2 - right^2 == 0
         if not (left * left - right * right).is_zero():
@@ -792,10 +797,10 @@ class _FactorizedSqrtLinCombination(object):
         while True:
             # Determine signs, None indicates the signs couldn't be certified
             opposite_signs = _opposite_signs(left, right, prec)
-            if not opposite_signs is None:
+            if opposite_signs is not None:
                 # Done
                 return opposite_signs
-            
+
             # Otherwise, increase precision
             prec *= 2
 
@@ -820,25 +825,26 @@ def _opposite_signs(left, right, prec):
         # It just means we need to use higher precision.
         # So just return "None" to indicate failed certification.
         return None
-    
+
     # Try to determine sign of left expression.
-    left_negative    = bool(left_interval  < 0)
-    left_positive    = bool(left_interval  > 0)
-    left_determined  = left_negative  or left_positive
-    
+    left_negative = bool(left_interval < 0)
+    left_positive = bool(left_interval > 0)
+    left_determined = left_negative or left_positive
+
     # Try to determine sign of right expression
-    right_negative   = bool(right_interval < 0)
-    right_positive   = bool(right_interval > 0)
+    right_negative = bool(right_interval < 0)
+    right_positive = bool(right_interval > 0)
     right_determined = right_negative or right_positive
-    
+
     # If both signs could be determined
     if left_determined and right_determined:
         # Return true if and only if signs are opposite
         return left_positive ^ right_positive
-    
+
     # At least one sign couldn't be determined.
     return None
 
+
 def _first(iterable):
     """
     Return first element of iterable.
@@ -846,6 +852,7 @@ def _first(iterable):
     for i in iterable:
         return i
 
+
 def _firstfirst(iterable):
     """
     Given a nested iterable, i.e., list of lists, return the first element
@@ -855,20 +862,14 @@ def _firstfirst(iterable):
         for j in i:
             return j
 
-def _prod(s):
-    """
-    The product of the elements in s. Returns Sage Integer(1)
-    when s is empty.
-    """
-    return reduce(operator.mul, s, _One)
 
 def _filter_zero(d):
     """
     Given a dict, filter out all items where the value is 0.
     """
+    return {k: v for k, v in d.items() if v != 0}
+
 
-    return dict( (k, v) for k, v in d.items() if not v == 0)
- 
 def _convert_to_allowed_type(number):
     """
     When given a Python int, convert to Sage Integer (so that
@@ -887,6 +888,7 @@ def _convert_to_allowed_type(number):
 
     raise Exception("Not an allowed type")
 
+
 def _get_embed_cache(l1, l2):
     """
     Given objects of type SqrtLinCombination or _FactorizedSqrtLinCombination
@@ -900,7 +902,7 @@ def _get_embed_cache(l1, l2):
     for l in [l1, l2]:
         if ((isinstance(l, SqrtLinCombination) or
              isinstance(l, _FactorizedSqrtLinCombination)) and
-            not l._embed_cache is None):
+            l._embed_cache is not None):
             return l._embed_cache
 
     return None
@@ -932,33 +934,34 @@ def _get_interval_embedding_from_cache(nf, RIF, cache):
     #     print("Warning: No cache used")
 
     # The key 'gen_embedding' holds the value of nf.gen_embedding()
-    if (not cache is None) and 'gen_embedding' in cache:
+    if cache is not None and 'gen_embedding' in cache:
         # We can read it from cache
         gen_embedding = cache['gen_embedding']
     else:
         # We need to evaluate it
         gen_embedding = nf.gen_embedding()
-        if (not cache is None):
+        if cache is not None:
             # Save in cache for future use
             cache['gen_embedding'] = gen_embedding
 
     # Get the desired precision of the RealIntervalField
     prec = RIF.prec()
     # The precision (which is an int) is the key into the cache
-    if (not cache is None) and prec in cache:
+    if cache is not None and prec in cache:
         # RIF(nf.gen_embedding()) is in the cache
         # We can just return the result
         return cache[prec]
-    
+
     # We need to actually compute it.
     interval = RIF(gen_embedding)
-    if not cache is None:
+    if cache is not None:
         # Save in cache for future use.
         cache[prec] = interval
 
     return interval
 
-def _to_RIF(x, RIF, embed_cache = None):
+
+def _to_RIF(x, RIF, embed_cache=None):
     """
     Given a Sage Integer, Rational or an element x in a
     Sage NumberField with a real embedding and an instance
@@ -996,6 +999,7 @@ def _to_RIF(x, RIF, embed_cache = None):
     # at the root
     return x.lift()(root)
 
+
 if __name__ == '__main__':
     import doctest
     doctest.testmod()

snappy/verify/test.py

@@ -1,32 +1,19 @@
-from snappy import verify, Manifold
-from snappy.verify import upper_halfspace, cusp_shapes, cusp_areas, volume
-from snappy.sage_helper import _within_sage, doctest_modules
-import sys, getopt
+from snappy import testing
+import snappy
 
-def check_certified_intervals():
-    for n in ['m009', 'm015', 't02333', 't02333(1,2)',
-              'm129(2,3)', 'm129(2,3)(3,4)']:
-        M = Manifold(n)
-        high_prec = M.tetrahedra_shapes('rect', bits_prec = 1000)
-        
-        intervals = M.tetrahedra_shapes('rect', bits_prec = 100,
-                                        intervals = True)
-
-        for z, interval in zip(high_prec, intervals):
-            if not abs(interval.center() - z) < 1e-10:
-                raise Exception
-
-            if not z in interval:
-                raise Exception
+from snappy import verify
 
 def generate_test_with_shapes_engine(module, engine):
-    def result(verbose):
-        globs = {'Manifold':Manifold}
+    def result(verbose, print_info=True):
+        globs = {'Manifold' : snappy.Manifold}
 
         original = verify.CertifiedShapesEngine
         verify.CertifiedShapesEngine = engine
 
-        r = doctest_modules([module], extraglobs = globs, verbose = verbose)
+        r = testing.doctest_modules([ module ],
+                                    verbose=verbose,
+                                    print_info=print_info,
+                                    extraglobs=globs)
 
         verify.CertifiedShapesEngine = original
 
@@ -36,41 +23,56 @@ def generate_test_with_shapes_engine(module, engine):
 
     return result
 
+modules = [
+    generate_test_with_shapes_engine(
+        verify.krawczyk_shapes_engine,
+        verify.KrawczykShapesEngine),
+    generate_test_with_shapes_engine(
+        verify.interval_newton_shapes_engine,
+        verify.IntervalNewtonShapesEngine),
+    generate_test_with_shapes_engine(
+        verify.hyperbolicity,
+        verify.KrawczykShapesEngine),
+    generate_test_with_shapes_engine(
+        verify.hyperbolicity,
+        verify.IntervalNewtonShapesEngine),
+    verify.canonical,
+    verify.interval_tree,
+    verify.volume,
+    verify.upper_halfspace.ideal_point,
+    verify.upper_halfspace.finite_point,
+    verify.upper_halfspace.extended_matrix,
+    verify.maximal_cusp_area_matrix,
+    verify.maximal_cusp_area_matrix.cusp_tiling_engine,
+    verify.maximal_cusp_area_matrix.cusp_translate_engine,
+    verify.square_extensions,
+    verify.real_algebra
+]
+
 def run_doctests(verbose=False, print_info=True):
-    globs = {'Manifold':Manifold}
-
-    return doctest_modules(
-        [
-            generate_test_with_shapes_engine(
-                verify.krawczyk_shapes_engine,
-                verify.KrawczykShapesEngine),
-            generate_test_with_shapes_engine(
-                verify.interval_newton_shapes_engine,
-                verify.IntervalNewtonShapesEngine),
-            verify.cuspCrossSection,
-            generate_test_with_shapes_engine(
-                verify.verifyHyperbolicity,
-                verify.KrawczykShapesEngine),
-            generate_test_with_shapes_engine(
-                verify.verifyHyperbolicity,
-                verify.IntervalNewtonShapesEngine),
-            verify.verifyCanonical,
-            verify.interval_tree,
-            volume,
-            cusp_areas,
-            cusp_shapes,
-            upper_halfspace.ideal_point,
-            upper_halfspace.finite_point,
-            upper_halfspace.extended_matrix,
-            verify.maximal_cusp_area_matrix,
-            verify.maximal_cusp_area_matrix.cusp_tiling_engine,
-            verify.maximal_cusp_area_matrix.cusp_translate_engine,
-            verify.squareExtensions,
-            verify.realAlgebra ],
-        extraglobs=globs,
-        verbose=verbose, print_info=print_info)
+    globs = {'Manifold' : snappy.Manifold}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = verify.__name__
+
+def check_certified_intervals():
+    for n in ['m009', 'm015', 't02333', 't02333(1,2)',
+              'm129(2,3)', 'm129(2,3)(3,4)']:
+        M = Manifold(n)
+        high_prec = M.tetrahedra_shapes('rect', bits_prec=1000)
+
+        intervals = M.tetrahedra_shapes('rect', bits_prec=100,
+                                        intervals=True)
+
+        for z, interval in zip(high_prec, intervals):
+            if not abs(interval.center() - z) < 1e-10:
+                raise Exception
+
+            if z not in interval:
+                raise Exception
 
 if __name__ == '__main__':
-    optlist, args = getopt.getopt(sys.argv[1:], 'v', ['verbose'])
-    verbose = len(optlist) > 0
-    run_doctests(verbose)
+    testing.run_doctests_as_main(run_doctests)