snappy 3.1.1__cp312-cp312-win_amd64.whl → 3.2__cp312-cp312-win_amd64.whl

snappy/testing.py

@@ -0,0 +1,131 @@
+from .numeric_output_checker import NumericOutputChecker
+from .sage_helper import _within_sage
+
+import doctest
+import getopt
+import re
+import sys
+import types
+
+# Used for doctesting
+_gui_status = {}
+
+try:
+    from snappy.gui import Tk_
+    _gui_status['tk'] = True
+except ImportError:
+    _gui_status['tk'] = False
+if _gui_status['tk']:
+    try:
+        import snappy.CyOpenGL
+        _gui_status['cyopengl'] = True
+    except:
+        _gui_status['cyopengl'] = False
+else:
+    _gui_status['cyopengl'] = False
+_gui_status['fake_root'] = False
+
+def cyopengl_works():
+    if not _gui_status['cyopengl']:
+        return False
+    # if we are running the tests from the snappy app the default root will
+    # already exist -- it will be the tkterminal window.  Otherwise, we open
+    # a root window here to serve as the master of all of the GUI windows
+    # which get created during testing.
+    if _gui_status['tk'] and not Tk_._default_root:
+        try:
+            root = Tk_.Tk()
+            if sys.platform not in ('linux', 'linux2'):
+                root.withdraw()
+        except:
+            # tkinter loads OK but is not able to get a display.
+            _gui_status['tk'] = _gui_status['cyopengl'] = False
+    return _gui_status['cyopengl']
+
+
+def tk_root():
+    if _gui_status['tk']:
+        return Tk_._default_root
+    else:
+        return None
+
+def root_is_fake():
+    return _gui_status['fake_root']
+
+class DocTestParser(doctest.DocTestParser):
+    use_cyopengl = False
+    use_cymodernopengl = True
+    use_sage = _within_sage
+
+    def parse(self, string, name='<string>'):
+        string = re.subn(
+            r'#doctest: \+CYOPENGL',
+            '' if DocTestParser.use_cyopengl else '#doctest: +SKIP',
+            string)[0]
+
+        string = re.subn(
+            r'#doctest: \+CYMODERNOPENGL',
+            (''
+             if (DocTestParser.use_cyopengl and
+                 DocTestParser.use_cymodernopengl)
+             else '#doctest: +SKIP'),
+            string)[0]
+
+        if DocTestParser.use_sage:
+            string = re.subn(r'(\n\s*)sage:|(\A\s*)sage:',
+                             r'\g<1>>>>',
+                             string)[0]
+        return doctest.DocTestParser.parse(self, string, name)
+
+if _within_sage:
+    try:
+        from sage.all import PSL, BraidGroup
+    except ImportError:
+        import sage.groups.perm_gps.permgroup_element
+        from sage.groups.perm_gps.permgroup_named import PSL
+        from sage.groups.braid import BraidGroup
+    globs = {'PSL': PSL, 'BraidGroup': BraidGroup}
+else:
+    globs = {}
+
+def print_results(module, results):
+    root = tk_root()
+    # Platform specific hacks to make running the tests work.
+    if root and not root_is_fake():
+        if sys.platform in ('linux', 'linux2'):
+            root.deiconify()
+            root.update_idletasks()
+        else:
+            root.update()
+    print(module.__name__ + ':')
+    print('   %s failures out of %s tests.' % (results.failed,
+                                               results.attempted))
+
+def doctest_modules(modules, verbose=False, print_info=False, extraglobs={}):
+    finder = doctest.DocTestFinder(parser=DocTestParser())
+    full_extraglobals = globs.copy()
+    full_extraglobals.update(extraglobs)
+    failed, attempted = 0, 0
+    for module in modules:
+        if isinstance(module, types.ModuleType):
+            runner = doctest.DocTestRunner(checker=NumericOutputChecker(), verbose=verbose)
+            for test in finder.find(module, extraglobs=full_extraglobals):
+                runner.run(test)
+            result = runner.summarize()
+        else:
+            result = module(verbose=verbose, print_info=False)
+        failed += result.failed
+        attempted += result.attempted
+        if print_info:
+            print_results(module, result)
+
+    if print_info:
+        print('\nAll doctests:\n   %s failures out of %s tests.' % (failed, attempted))
+    return doctest.TestResults(failed, attempted)
+
+def run_doctests_as_main(run_doctests):
+    optlist, args = getopt.getopt(sys.argv[1:], 'v', ['verbose'])
+    verbose = len(optlist) > 0
+    results = run_doctests(verbose=verbose, print_info=True)
+    sys.exit(results.failed)
+

snappy/tiling/__init__.py

@@ -0,0 +1,2 @@
+# Tiling H^3 or quotients of H^3
+

snappy/tiling/canonical_key_dict.py

@@ -0,0 +1,59 @@
+class CanonicalKeyDict:
+    """
+    Applies a function to canonize key before looking it up
+    or setting it in the supplied dictionary.
+
+    Note that the function can return a set of multiple
+    canidadates for the canonical key. The look-ups in the
+    dictionary will work correctly, as long as the true canonical
+    key is among the candidates.
+
+    # Modulo 5, canonical representative is 0, 1, ... 4.
+
+    >>> d = CanonicalKeyDict({}, canonical_keys_function = lambda x : x)
+    >>> d.setdefault([1], []).append('A')
+    >>> d.setdefault([2, 7], []).append('B')
+    >>> d.setdefault([1,6], [])
+    ['A']
+    >>> d.setdefault([1,6], []).append('C')
+    >>> d.setdefault([1,6], [])
+    ['A', 'C']
+    >>> d.setdefault([1], [])
+    ['A', 'C']
+    >>> d.setdefault([1, 11], [])
+    ['A', 'C']
+    >>> d.setdefault([2], [])
+    ['B']
+    """
+
+    def __init__(self, dictionary, canonical_keys_function):
+        self._dictionary = dictionary
+        self._canonical_keys_function = canonical_keys_function
+
+    # Not implemented because it was not needed so far:
+    # get
+    # __getitem__
+    # __setitem__
+
+    # Note that __setitem__ requires updating all entries in
+    # self._dictionary.
+    # The easiest way to do this is to wrap the value into
+    # wrapped_value = [value], and assign to wrapped_value[0].
+    # This would also allow self.setdefault(key, None).
+
+    def setdefault(self, key, default):
+        if default is None:
+            raise Exception("Implementation reserved default = None for "
+                            "internal purposes.")
+
+        computed_keys = self._canonical_keys_function(key)
+
+        for computed_key in computed_keys:
+            value = self._dictionary.get(computed_key)
+            if not value is None:
+                return value
+
+        for computed_key in computed_keys:
+            self._dictionary[computed_key] = default
+
+        return default

snappy/tiling/dict_based_set.py

@@ -0,0 +1,79 @@
+class DictBasedSet:
+    """
+    This class can be constructed from a dictionary with keys in A.
+
+    The resulting object is a set of A.
+
+    >>> fruit_set = DictBasedSet(dict())
+    >>> fruit_set.add('Apple')
+    True
+    >>> fruit_set.add('Banana')
+    True
+    >>> fruit_set.add('Apple') # Already added earlier
+    False
+
+    """
+
+    def __init__(self, dictionary):
+        self._dictionary = dictionary
+
+    def add(self, key) -> bool:
+        """
+        Adds key to set of A.
+
+        Returns true if key was not yet in the set.
+        """
+        visited = self._dictionary.setdefault(key, [False])
+        if visited[0]:
+            return False
+        visited[0] = True
+        return True
+
+class DictBasedProductSet:
+    """
+    This class can be constructed from a dictionary with keys in A.
+
+    The resulting object is a set of AxB.
+
+    Can be combined with RealHashDict or CanonicalKeyDict.
+
+    >>> fruit_number_set = DictBasedProductSet(dict())
+    >>> fruit_number_set.add('Apple', 1)
+    True
+    >>> fruit_number_set.add('Banana', 1)
+    True
+    >>> fruit_number_set.add('Apple', 2)
+    True
+    >>> fruit_number_set.add('Apple', 1) # Already added earlier
+    False
+
+    """
+
+    def __init__(self, dictionary):
+        self._dictionary = dictionary
+
+    def add(self, key, element) -> bool:
+        """
+        Adds (key, element) in AxB to set.
+
+        Returns true if (key, element) was not yet in the set.
+        """
+        
+        elements = self._get_elements_for_key(key)
+        if element in elements:
+            return False
+        else:
+            elements.add(element)
+            return True
+
+    def _get_elements_for_key(self, key):
+        """
+        Could be used for potential future optimization:
+        When going to a neighboring tetrahedron paired through
+        a trivial face-pairing matrix (so it is a tetrahedron within
+        the same copy of the fundamental polyhedron), we can keep
+        a reference to the set returned by _get_elements_for_key
+        and just add the neighboring tetrahedron to this set rather
+        than doing the look-up from scratch.
+        """
+        return self._dictionary.setdefault(key, set())

snappy/tiling/floor.py

@@ -0,0 +1,49 @@
+from ..math_basics import is_RealIntervalFieldElement # type: ignore
+from ..exceptions import InsufficientPrecisionError # type: ignore
+
+from typing import Sequence
+
+def floor_as_integers(x) -> Sequence[int]:
+    """
+    Computes floor of a number or interval, returning a list of integers
+    if evaluating floor is ambiguous.
+
+        sage: from sage.all import RIF
+        sage: floor_as_integers(RIF(1.8, 1.9))
+        [1]
+        sage: floor_as_integers(RIF(1.9, 2.1))
+        [1, 2]
+
+        >>> from snappy.number import *
+        >>> def to_number(py_float):
+        ...     return number_to_native_number(SnapPyNumbers(100)(py_float))
+        >>> floor_as_integers(to_number(1.4))
+        [1]
+        >>> floor_as_integers(to_number(2.01))
+        [1, 2]
+        >>> floor_as_integers(to_number(1.99))
+        [1, 2]
+
+    """
+
+    if is_RealIntervalFieldElement(x):
+        f = x.floor()
+        l = f.lower().round()
+        u = f.upper().round() + 1
+
+        n = u - l
+        if n > 5:
+            raise InsufficientPrecisionError(
+                "Too many integers (%d) in given interval to compute floor. "
+                "Increasing precision should fix it." % n)
+
+        return list(range(l, u))
+    else:
+        f = x.floor()
+        int_f = int(f)
+        d = x - f
+        if d < 0.125:
+            return [ int_f - 1, int_f ]
+        if d > 0.875:
+            return [ int_f, int_f + 1 ]
+        return [ int_f ]

snappy/tiling/hyperboloid_dict.py

@@ -0,0 +1,54 @@
+from .real_hash_dict import RealHashDict
+from ..hyperboloid import r13_dot
+from ..exceptions import InsufficientPrecisionError # type: ignore
+
+def get_hyperboloid_dict(max_neg_prod_equal, min_neg_prod_distinct,
+                         verified):
+    RF = max_neg_prod_equal.parent()
+    return RealHashDict(
+        _equality_predicate(max_neg_prod_equal, min_neg_prod_distinct),
+        _hash_function(RF),
+        _compute_epsilon_inverse(RF),
+        verified)
+
+def _equality_predicate(max_neg_prod_equal, min_neg_prod_distinct):
+    def result(point_0, point_1):
+        neg_inner_product = -r13_dot(point_0, point_1)
+        if neg_inner_product < max_neg_prod_equal:
+            return True
+        if neg_inner_product > min_neg_prod_distinct:
+            return False
+
+        raise InsufficientPrecisionError(
+            "Could neither verify that the two given tiles are "
+            "the same nor that they are distinct.\n"
+            "Neg inner product is:     %r.\n"
+            "Max to be same tile:      %r.\n"
+            "Min to be distinct tiles: %r." % (
+                neg_inner_product, max_neg_prod_equal, min_neg_prod_distinct))
+
+    return result
+
+def _hash_function(RF):
+    weights = [ RF(1.2003), RF(0.94553), RF(1.431112), RF(1.2342) ]
+
+    def result(point):
+        return (point[0] * weights[0] +
+                point[1] * weights[1] +
+                point[2] * weights[2] +
+                point[3] * weights[3])
+
+    return result
+
+_default_epsilon_inverse = 128
+
+def _compute_epsilon_inverse(RF):
+    result = _default_epsilon_inverse
+
+    p = RF.precision()
+    if p > 53:
+        result *= 2 ** ((p - 53) // 3)
+
+    return result
+
+

snappy/tiling/iter_utils.py

@@ -0,0 +1,78 @@
+from itertools import count
+
+class IteratorCache:
+    def __init__(self, iterator):
+        """
+        Takes an iterator and produces an iterable such that an
+        iterator created from the iterable produces the same iterated
+        values.
+
+        The iterates values, however, are lazily cached so that
+        iterating over another iterator again is faster.
+
+        (Silly) Example:
+
+            >>> squares = IterableCache(iter(i ** 2 for i in range(1000)))
+            >>> iterator0 = iter(squares)
+            >>> next(iterator0)
+            0
+            >>> next(iterator0)
+            1
+            >>> next(iterator0)
+            4
+            >>> iterator1 = iter(squares)
+            >>> next(iterator1) # Cached from previous run
+            0
+            >>> next(iterator1)
+            1
+            >>> next(iterator1)
+            4
+            >>> next(iterator1) # Not cached from previous run
+            9
+
+        """
+
+        self._iterator = iterator
+        self._cache = []
+
+    def __iter__(self):
+        for i in count():
+            if i == len(self._cache):
+                try:
+                    n = next(self._iterator)
+                except StopIteration:
+                    break
+                self._cache.append(n)
+            yield self._cache[i]
+
+def merge_iterators(iterators):
+    """
+    Merges iterators into one iterable picking the smallest element
+    (using < operator) from the list of next elements for each iterator.
+    """
+
+    elements  = [ [ next(iter), i ]
+                  for i, iter in enumerate(iterators) ]
+
+    while True:
+        element, i = min(elements)
+        yield element
+
+        elements[i][0] = next(iterators[i])
+
+def merge_iterables(iterables):
+    """
+    Merges iterables into one iterable picking the smallest element
+    (using < operator) from the list of next elements for each iterator.
+
+    Example:
+
+        >>> squares_and_cubes = iter(merge_iterables([
+        ...          (i ** 2 for i in range(10000)),
+        ...          (i ** 3 for i in range(10000)) ]))
+        >>> list(islice(squares_and_cubes, 12))
+        [0, 0, 1, 1, 4, 8, 9, 16, 25, 27, 36, 49]
+
+    """
+
+    return merge_iterators([ iter(i) for i in iterables ])

snappy/tiling/lifted_tetrahedron.py

@@ -0,0 +1,22 @@
+from ..snap.t3mlite import Tetrahedron # type: ignore
+
+# @dataclass - not supported until python 3.7. We support 3.6.
+
+class LiftedTetrahedron:
+    """
+    Represents the lift of a tetrahedron in a manifold to the hyperboloid
+    model.
+
+    That is, if a tetrahedron (as part of the fundamental domain) was assigned
+    vertices by calling add_r13_geometry, then the vertices of a
+    LiftedTetrahedron l will be given by l.o13_matrices * tet.R13_vertices[v]
+    where v in snappy.snap.t3mlite.simplex.ZeroSubsimplices.
+    """
+
+    def __init__(self,
+                 tet : Tetrahedron,
+                 # An O(1,3)-matrix - since this might be a SageMath class or a
+                 # SimpleMatrix, just using Any as type annotation.
+                 o13_matrix):
+        self.tet = tet
+        self.o13_matrix = o13_matrix

snappy/tiling/lifted_tetrahedron_set.py

@@ -0,0 +1,54 @@
+from .lifted_tetrahedron import LiftedTetrahedron
+from .canonical_key_dict import CanonicalKeyDict
+from .dict_based_set import DictBasedProductSet
+from .hyperboloid_dict import get_hyperboloid_dict
+
+from ..hyperboloid import o13_inverse
+
+class LiftedTetrahedronSet:
+    """
+    A set of lifted tetrahedra in H^3 or a quotient space of
+    H^3.
+
+    Which space will be used is determined by the dictionary
+    given when LiftedTetrahedronSet is constructed.
+    """
+
+    def __init__(self, dictionary, base_point, act_on_base_point_by_inverse):
+        self._set = DictBasedProductSet(dictionary)
+        self._base_point = base_point
+        self._act_on_base_point_by_inverse = act_on_base_point_by_inverse
+
+    def add(self, lifted_tetrahedron : LiftedTetrahedron) -> bool:
+        if self._act_on_base_point_by_inverse:
+            m = o13_inverse(lifted_tetrahedron.o13_matrix)
+        else:
+            m = lifted_tetrahedron.o13_matrix
+        
+        return self._set.add(
+            m * self._base_point,
+            lifted_tetrahedron.tet.Index)
+
+def get_lifted_tetrahedron_set(base_point,
+                               canonical_keys_function,
+                               act_on_base_point_by_inverse,
+                               max_neg_prod_equal, min_neg_prod_distinct,
+                               verified
+                               ) -> LiftedTetrahedronSet:
+    """
+    Returns a set to store lifted tetrahedra in H^3 or a quotient
+    space of H^3.
+
+    The type of geometric object determined which space will be used.
+
+    """
+
+    d = get_hyperboloid_dict(max_neg_prod_equal, min_neg_prod_distinct,
+                             verified)
+
+    if canonical_keys_function:
+        d = CanonicalKeyDict(d, canonical_keys_function)
+
+    return LiftedTetrahedronSet(d, base_point, act_on_base_point_by_inverse)
+
+

snappy/tiling/real_hash_dict.py

@@ -0,0 +1,164 @@
+from ..verify.interval_tree import IntervalTree
+from .floor import floor_as_integers
+
+# For experimenting how the performance of the IntervalTree compares
+# to using a python dict.
+#
+# Sadly, the IntervalTree is implemented in slow python and not fast
+# C(++). This is because we do not have access to the mpfi number since
+# we cannot include .pyd files from SageMath :(
+#
+_use_interval_tree = True
+
+class RealHashDict:
+    """
+    A dictionary (following python dict API) where we provide for the keys:
+    - a predicate that decides whether two keys are the same
+    - a hash function returning an approximation of a real number
+
+    The use case is, for example, to use as keys points in a metric space
+    that are given by approximate numbers. Two close by approximations are
+    probably the same point.
+
+    The requirements of the hash function has the following requirements:
+    - If it is an interval, it has to contain the true hash value, that is
+      the true value of the hash function evaluated for the true value of
+      the key.
+    - If it is an interval and _use_interval_tree is False, the length of
+      the interval cannot be much larger than 1/epsilon_inverse.
+    - If it is a floating point number, the approximation cannot differ
+      from the true value by more than 1/epsilon_inverse/16.
+
+    Example Z as a discrete subset of R::
+
+    >>> from snappy.number import *
+    >>> def to_number(py_float):
+    ...     return number_to_native_number(SnapPyNumbers(100)(py_float))
+
+    >>> d = RealHashDict(
+    ...        # If two floating approximations of integers are close by,
+    ...        # they must be the same
+    ...        equality_predicate = lambda x, y: abs(x - y) < to_number(0.5),
+    ...        # For space with more than 1-dimension, use some function
+    ...        # involving the other coordinates
+    ...        hash_function = lambda x : x,
+    ...        epsilon_inverse = 1024,
+    ...        verified = False)
+
+    # Keys near 1 should be treated as the same.
+    >>> d[to_number(1.0)] = 'A'
+    >>> d[to_number(1.0000001)] = 'B'
+    >>> d.get(to_number(0.9999999))
+    'B'
+
+    >>> d.setdefault(to_number(10 + 0.1 / 1024), []).append('A')
+    >>> d.get(to_number(10.0))
+    ['A']
+    >>> d.setdefault(to_number(10 - 0.1 / 1024), []).append('B')
+    >>> d.get(to_number(10.0000001))
+    ['A', 'B']
+
+    sage: from sage.all import RIF
+    sage: def equality_predicate(x, y):
+    ...       d = abs(x - y)
+    ...       if d < RIF(0.1):
+    ...           return True
+    ...       if d > 0:
+    ...           return False
+    ...       raise Exception("Could not determine whether points are the "
+    ...                       "same or not")
+    sage: d = RealHashDict(
+    ...        equality_predicate = equality_predicate,
+    ...        hash_function = lambda x : x,
+    ...        epsilon_inverse = 1024,
+    ...        verified = True)
+
+    # Keys near 1 should be treated as the same.
+    sage: d[RIF(0.9999999, 1.000001)] = 'A'
+    sage: d[RIF(0.9999998, 1.0000001)] = 'B'
+    sage: d.get(RIF(0.99999997, 1.0000002))
+    'B'
+    
+    sage: d.setdefault(RIF(9.9999999, 10.00001), []).append('A')
+    sage: d.get(RIF(10.0))
+    ['A']
+    sage: d.setdefault(RIF(9.9999993, 10.00002), []).append('B')
+    sage: d.get(RIF(9.99999999, 10.0000001))
+    ['A', 'B']
+
+    sage: from snappy.tiling import real_hash_dict
+    sage: original_use_interval_tree = real_hash_dict._use_interval_tree
+    sage: real_hash_dict._use_interval_tree = True
+    sage: d = RealHashDict(
+    ...        equality_predicate = equality_predicate,
+    ...        hash_function = lambda x : x,
+    ...        epsilon_inverse = 1024,
+    ...        verified = True)
+    sage: d[RIF(1.0)] = 'A'
+    sage: d[RIF(0.7, 1.3)] = 'B'
+    Traceback (most recent call last):
+    ...
+    Exception: Could not determine whether points are the same or not
+    sage: real_hash_dict._use_interval_tree = original_use_interval_tree
+    
+    
+    """
+
+    def __init__(self, equality_predicate, hash_function, epsilon_inverse, verified):
+
+        self._equality_predicate = equality_predicate
+        self._hash_function = hash_function
+
+        if verified and _use_interval_tree:
+            self._impl = IntervalTree()
+        else:
+            self._impl = _Dict(epsilon_inverse)
+
+    def get(self, key, default = None):
+        h = self._hash_function(key)
+
+        for other_key, value in self._impl.find(h):
+            if self._equality_predicate(key, other_key):
+                return value
+
+        return default
+
+    # Not implemented because it was not needed yet:
+    # __getitem__
+
+    def __setitem__(self, key, value):
+        h = self._hash_function(key)
+
+        for pair in self._impl.find(h):
+            if self._equality_predicate(key, pair[0]):
+                pair[1] = value
+                return
+        
+        self._impl.insert(h, [key, value])
+
+    def setdefault(self, key, default):
+        h = self._hash_function(key)
+
+        for other_key, value in self._impl.find(h):
+            if self._equality_predicate(key, other_key):
+                return value
+
+        self._impl.insert(h, [key, default])
+
+        return default
+
+class _Dict:
+    def __init__(self, epsilon_inverse):
+        self._epsilon_inverse = epsilon_inverse
+        self._dict = {}
+
+    def insert(self, key, value):
+        for computed_key in self._computed_keys(key):
+            self._dict.setdefault(computed_key, []).append(value)
+
+    def find(self, key):
+        for computed_key in self._computed_keys(key):
+            yield from self._dict.get(computed_key, [])
+
+    def _computed_keys(self, key):
+        return floor_as_integers(key * self._epsilon_inverse)