snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

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 .quotient_dict import QuotientDict
+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_representatives_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_representatives_function:
+        d = QuotientDict(d, canonical_representatives_function)
+
+    return LiftedTetrahedronSet(d, base_point, act_on_base_point_by_inverse)
+
+

snappy/tiling/quotient_dict.py

@@ -0,0 +1,70 @@
+class QuotientDict:
+    """
+    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 = QuotientDict({}, canonical_representative_function = lambda x : [x % 5])
+    >>> d.setdefault(1, []).append('A')
+    >>> d.setdefault(2, []).append('B')
+    >>> d.setdefault(6, []).append('C')
+    >>> d.setdefault(1, [])
+    ['A', 'C']
+
+    # Test with a fuzzy "Modulo 5" that always includes
+    # the canonical representative in 0, 1, ... 4 but sometimes
+    # an additional representative.
+
+    >>> d = QuotientDict({}, canonical_representative_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_representative_function):
+        self._dictionary = dictionary
+        self._canonical_representative_function = canonical_representative_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 = []
+        for computed_key in self._canonical_representative_function(key):
+            value = self._dictionary.get(computed_key)
+            if not value is None:
+                return value
+            computed_keys.append(computed_key)
+
+        for computed_key in computed_keys:
+            self._dictionary[computed_key] = default
+
+        return default

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)

snappy/tiling/test.py

@@ -0,0 +1,23 @@
+from snappy import testing
+import snappy
+
+from snappy import tiling
+
+modules = [
+    tiling.floor,
+    tiling.real_hash_dict,
+    tiling.quotient_dict,
+    tiling.dict_based_set
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold': snappy.Manifold}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = tiling.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)