snappy 3.2__cp311-cp311-macosx_10_12_x86_64.whl

snappy/ptolemy/testing_files/data/pgl2/OrientableCuspedCensus/03_tetrahedra/m019__sl2_c0.magma_out

@@ -0,0 +1,95 @@
+Magma V2.19-8     Tue Aug 20 2013 16:07:18 on localhost [Seed = 947496497]
+Type ? for help.  Type <Ctrl>-D to quit.
+==TRIANGULATION=BEGINS==
+% Triangulation
+m019
+geometric_solution  2.94410649
+oriented_manifold
+CS_known 0.0000000000000001
+
+1 0
+    torus   0.000000000000   0.000000000000
+
+3
+   1    1    1    2 
+ 0132 2103 0321 0132
+   0    0    0    0 
+  0  0  0  0 -1  0  1  0  0  0  0  0  0 -1  1  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0 -1  0  1  0  0  0  0  0  0  0  0  1  0 -1  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0.780552527851   0.914473662968
+
+   0    0    0    2 
+ 0132 2103 0321 1023
+   0    0    0    0 
+  0  0  0  0  1  0 -1  0  0  0  0  0  0  1 -1  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0  0  0  0  0  1 -1 -1  1  0  0  0  0  0  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0.780552527851   0.914473662968
+
+   2    2    0    1 
+ 1230 3012 0132 1023
+   0    0    0    0 
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0 -1  1  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0.460021175574   0.632624193605
+
+
+==TRIANGULATION=ENDS==
+PY=EVAL=SECTION=BEGINS=HERE
+{'variable_dict' : 
+     (lambda d, negation = (lambda x:-x): {
+          's_3_1' : d['1'],
+          's_3_2' : d['1'],
+          's_3_0' : d['1'],
+          's_2_0' : d['1'],
+          's_2_1' : d['1'],
+          's_2_2' : d['1'],
+          's_1_2' : d['1'],
+          's_1_1' : d['1'],
+          's_1_0' : d['1'],
+          's_0_2' : d['1'],
+          's_0_0' : d['1'],
+          's_0_1' : d['1'],
+          'c_1100_1' : negation(d['c_0011_0']),
+          'c_1100_0' : d['c_0011_0'],
+          'c_1100_2' : d['c_0011_0'],
+          'c_0101_2' : negation(d['c_0101_0']),
+          'c_0101_1' : negation(d['c_0101_0']),
+          'c_0101_0' : d['c_0101_0'],
+          'c_0011_1' : negation(d['c_0011_0']),
+          'c_0011_0' : d['c_0011_0'],
+          'c_0011_2' : d['c_0011_2'],
+          'c_1001_1' : d['c_0011_0'],
+          'c_1001_0' : negation(d['c_0011_0']),
+          'c_1001_2' : negation(d['c_0011_2']),
+          'c_0110_1' : d['c_0101_0'],
+          'c_0110_0' : negation(d['c_0101_0']),
+          'c_0110_2' : d['c_0011_2'],
+          'c_1010_2' : d['c_0101_0'],
+          'c_1010_1' : d['c_0011_2'],
+          'c_1010_0' : negation(d['c_0011_2'])})}
+PY=EVAL=SECTION=ENDS=HERE
+PRIMARY=DECOMPOSITION=BEGINS=HERE
+[
+    Ideal of Polynomial ring of rank 4 over Rational Field
+    Order: Lexicographical
+    Variables: t, c_0011_0, c_0011_2, c_0101_0
+    Inhomogeneous, Dimension 0, Radical, Prime
+    Size of variety over algebraically closed field: 4
+    Groebner basis:
+    [
+        t - c_0101_0^3 + c_0101_0^2 + c_0101_0 + 2,
+        c_0011_0 - 1,
+        c_0011_2 + c_0101_0^3 - 2*c_0101_0 - 2,
+        c_0101_0^4 - 2*c_0101_0^2 - 3*c_0101_0 - 1
+    ]
+]
+PRIMARY=DECOMPOSITION=ENDS=HERE
+CPUTIME : 0.000
+
+Total time: 0.210 seconds, Total memory usage: 32.09MB

snappy/ptolemy/testing_files/data/pgl2/OrientableCuspedCensus/03_tetrahedra/m019__sl2_c1.magma_out

@@ -0,0 +1,95 @@
+Magma V2.19-8     Tue Aug 20 2013 16:07:18 on localhost [Seed = 930523454]
+Type ? for help.  Type <Ctrl>-D to quit.
+==TRIANGULATION=BEGINS==
+% Triangulation
+m019
+geometric_solution  2.94410649
+oriented_manifold
+CS_known 0.0000000000000001
+
+1 0
+    torus   0.000000000000   0.000000000000
+
+3
+   1    1    1    2 
+ 0132 2103 0321 0132
+   0    0    0    0 
+  0  0  0  0 -1  0  1  0  0  0  0  0  0 -1  1  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0 -1  0  1  0  0  0  0  0  0  0  0  1  0 -1  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0.780552527851   0.914473662968
+
+   0    0    0    2 
+ 0132 2103 0321 1023
+   0    0    0    0 
+  0  0  0  0  1  0 -1  0  0  0  0  0  0  1 -1  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0  0  0  0  0  1 -1 -1  1  0  0  0  0  0  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0.780552527851   0.914473662968
+
+   2    2    0    1 
+ 1230 3012 0132 1023
+   0    0    0    0 
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0 -1  1  0  0  0  0  0  0  0  0  0  0  0  0
+  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+  0.460021175574   0.632624193605
+
+
+==TRIANGULATION=ENDS==
+PY=EVAL=SECTION=BEGINS=HERE
+{'variable_dict' : 
+     (lambda d, negation = (lambda x:-x): {
+          's_3_1' : d['1'],
+          's_3_2' : d['1'],
+          's_3_0' : d['1'],
+          's_2_0' : negation(d['1']),
+          's_2_1' : negation(d['1']),
+          's_2_2' : d['1'],
+          's_1_2' : d['1'],
+          's_1_1' : negation(d['1']),
+          's_1_0' : negation(d['1']),
+          's_0_2' : d['1'],
+          's_0_0' : d['1'],
+          's_0_1' : d['1'],
+          'c_1100_1' : negation(d['c_0011_0']),
+          'c_1100_0' : d['c_0011_0'],
+          'c_1100_2' : d['c_0011_0'],
+          'c_0101_2' : negation(d['c_0101_0']),
+          'c_0101_1' : negation(d['c_0101_0']),
+          'c_0101_0' : d['c_0101_0'],
+          'c_0011_1' : negation(d['c_0011_0']),
+          'c_0011_0' : d['c_0011_0'],
+          'c_0011_2' : d['c_0011_2'],
+          'c_1001_1' : d['c_0011_0'],
+          'c_1001_0' : negation(d['c_0011_0']),
+          'c_1001_2' : negation(d['c_0011_2']),
+          'c_0110_1' : d['c_0101_0'],
+          'c_0110_0' : negation(d['c_0101_0']),
+          'c_0110_2' : d['c_0011_2'],
+          'c_1010_2' : d['c_0101_0'],
+          'c_1010_1' : d['c_0011_2'],
+          'c_1010_0' : negation(d['c_0011_2'])})}
+PY=EVAL=SECTION=ENDS=HERE
+PRIMARY=DECOMPOSITION=BEGINS=HERE
+[
+    Ideal of Polynomial ring of rank 4 over Rational Field
+    Order: Lexicographical
+    Variables: t, c_0011_0, c_0011_2, c_0101_0
+    Inhomogeneous, Dimension 0, Radical, Prime
+    Size of variety over algebraically closed field: 4
+    Groebner basis:
+    [
+        t + c_0101_0^3 + c_0101_0^2 + c_0101_0 + 2,
+        c_0011_0 - 1,
+        c_0011_2 + c_0101_0^3,
+        c_0101_0^4 + c_0101_0 - 1
+    ]
+]
+PRIMARY=DECOMPOSITION=ENDS=HERE
+CPUTIME : 0.000
+
+Total time: 0.200 seconds, Total memory usage: 32.09MB

snappy/ptolemy/utilities.py

@@ -0,0 +1,236 @@
+import re
+
+###########################################
+#   Methods to prepare and quote ASCII text
+
+
+def _break_line_iterator(line, line_length):
+    for i in range(0, len(line), line_length):
+        yield line[i:i + line_length]
+
+
+def break_long_lines(text, line_length=76):
+    """
+    Break lines in ASCII text text longer than line_length by inserting
+    newline characters preceded by backslash (thus the resulting lines might
+    be one character longer than line_length).
+
+    The reverse operation is join_long_lines, so
+    join_long_lines(break_long_lines(text)) is always returning text as long as
+    consisted of ASCII characters (even when text already had lines
+    ending in a backslash as those backslashes are specially escaped)!
+
+    This is consistent with the interpretation of the backslash newline
+    sequence by many languages such as magma, python, C, C++ which treat these
+    escaped newlines as non-existing. In particular, the result of
+    break_long_lines and the text itself is the same to these languages (as
+    long as the text didn't already contain lines ending in a backslash).
+
+    >>> text = "This is a long line.\\nThis is an even longer line.\\n"
+    >>> print(break_long_lines(text,8))
+    This is \\
+    a long l\\
+    ine.
+    This is \\
+    an even \\
+    longer l\\
+    ine.
+    <BLANKLINE>
+
+    >>> join_long_lines(break_long_lines(text, 8)) == text
+    True
+    """
+
+    def split_ending_backslash(line):
+        if len(line) > 0 and line[-1] == '\\':
+            return line[:-1], '\\\\\n'
+        return line, ''
+
+    def process_line(line):
+        line_without, ending_backslash = split_ending_backslash(line)
+
+        return ('\\\n'.join(_break_line_iterator(line_without, line_length)) +
+                ending_backslash)
+
+    return '\n'.join(process_line(line) for line in text.split('\n'))
+
+
+def join_long_lines(text):
+    """
+    Deletes all backslash newline sequences. Inverse of break_long_lines.
+    """
+    return text.replace('\\\n', '')
+
+
+def join_long_lines_deleting_whitespace(text):
+    """
+    Similar to join_long_lines, but also deletes whitespace following a
+    backslash newline sequence.
+
+    Programs such as magma break long integers by introducing a backslash
+    newline sequence and inserting extra whitespace for formatting.
+    join_long_lines_deleting_whitespace can be used to undo this and parse
+    the input normally.
+
+    >>> join_long_lines_deleting_whitespace("Text:\\\\\\n   More")
+    'Text:More'
+    >>> join_long_lines_deleting_whitespace("    1234\\\\\\n    5678").strip()
+    '12345678'
+    """
+    return re.sub(r'\\\n\s*', '', text)
+
+
+def quote_ascii_text(text):
+    r"""
+    Put the text in double quotes after escapes newlines, backslashes and
+    double quotes. Giving the result of quote_ascii_text to eval should give
+    the original string back if the string contained only ASCII characters.
+
+    Similarly, giving the result of quote_ascii_text to magma's print,
+    should give the original string back (magma's print might wrap long lines
+    though).
+
+    >>> text = 'Backslash:\\, Newline:\n, Quote: "'
+    >>> quote_ascii_text(text)
+    '"Backslash:\\\\, Newline:\\n, Quote: \\""'
+    >>> eval(quote_ascii_text(text)) == text
+    True
+    """
+
+    def process_char(char):
+        if char == '\n':
+            return '\\n'
+        if char == '\\':
+            return '\\\\'
+        if char == '"':
+            return '\\"'
+        return char
+
+    return '"' + ''.join(process_char(c) for c in text) + '"'
+
+
+##########################################################################
+#   Iterators going through all tuples of integers with a certain property
+
+def _lists_with_fixed_sum_iterator(N, l):
+    if l == 1:
+        yield [N]
+    else:
+        for i in range(N + 1):
+            for j in _lists_with_fixed_sum_iterator(N - i, l - 1):
+                yield [i] + j
+
+
+def tuples_with_fixed_sum_iterator(N, l, skipVertices=False):
+    """
+    Iterates through all l-tuples of non-negative integers summing up to N in
+    lexicographic order. If skipVertices is True, N-tuples containing N, i.e.,
+    of the form (0...0,N,0...0), are skipped.
+
+    >>> list(tuples_with_fixed_sum_iterator(2, 3))
+    [(0, 0, 2), (0, 1, 1), (0, 2, 0), (1, 0, 1), (1, 1, 0), (2, 0, 0)]
+    >>> list(tuples_with_fixed_sum_iterator(2, 3, skipVertices = True))
+    [(0, 1, 1), (1, 0, 1), (1, 1, 0)]
+
+    """
+    for i in _lists_with_fixed_sum_iterator(N, l):
+        if not (skipVertices and N in i):
+            yield tuple(i)
+
+
+def triples_with_fixed_sum_iterator(N, skipVertices=False):
+    """
+    Similar to tuples_with_fixed_sum_iterator for triples.
+
+    >>> list(triples_with_fixed_sum_iterator(2, skipVertices = True))
+    [(0, 1, 1), (1, 0, 1), (1, 1, 0)]
+    """
+    return tuples_with_fixed_sum_iterator(N, 3, skipVertices=skipVertices)
+
+
+def quadruples_with_fixed_sum_iterator(N, skipVertices=False):
+    """
+    Similar to tuples_with_fixed_sum_iterator for quadruples.
+
+    >>> list(quadruples_with_fixed_sum_iterator(2, skipVertices = True))
+    [(0, 0, 1, 1), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 1), (1, 0, 1, 0), (1, 1, 0, 0)]
+    """
+    return tuples_with_fixed_sum_iterator(N, 4, skipVertices=skipVertices)
+
+
+############################################################################
+#   A subclass of Python list such that calling a method calls the method on
+#   every object in the list.
+
+def _flatten(l, depth=1):
+    """
+    Flatten a list or subclass of list. It will flatten the
+    list until the given depth.
+
+    >>> _flatten([0, [1, 2], [[3, 4], 5]], depth = 1)
+    [0, 1, 2, [3, 4], 5]
+    >>> _flatten([0, [1, 2], [[3, 4], 5]], depth = 2)
+    [0, 1, 2, 3, 4, 5]
+    """
+    if depth == 0:
+        return l
+
+    result = []
+
+    for e in l:
+        if isinstance(e, list):
+            result += _flatten(e, depth - 1)
+        else:
+            result.append(e)
+
+    if isinstance(l, MethodMappingList):
+        return type(l)(result, p=l)
+
+    return result
+
+
+class MethodMappingList(list):
+    """
+    Like a list but allows calling a method on it means that it is called
+    for all its elements.
+
+    >>> a = MethodMappingList([2+1j, 3+2j, 4+2j])
+    >>> a.conjugate()
+    [(2-1j), (3-2j), (4-2j)]
+
+    This can be nested:
+
+    >>> b = MethodMappingList([1+1j, a])
+    >>> b.conjugate()
+    [(1-1j), [(2-1j), (3-2j), (4-2j)]]
+
+    Also supports flattening:
+
+    >>> b.flatten()
+    [(1+1j), (2+1j), (3+2j), (4+2j)]
+
+    """
+
+    def __init__(self, l=[], p=None):
+        super().__init__(l)
+
+    def __call__(self, *args, **kwargs):
+        return type(self)([elt(*args, **kwargs) for elt in self],
+                          p=self)
+
+    def __getattr__(self, attr):
+        return type(self)([getattr(e, attr) for e in self],
+                          p=self)
+
+    def flatten(self, depth=1):
+        return _flatten(self, depth=depth)
+
+
+def _test():
+    """
+    >>> text = "Line\\\\nLong Line\\\\\\nVery long line and...\\nHere \\n\\n \\n\\n \\n \\\\n"
+    >>> for i in range(1, 80):
+    ...     if not join_long_lines(break_long_lines(text, i)) == text:
+    ...         raise Exception("Test failure")
+    """
+    pass

snappy/raytracing/__init__.py

@@ -0,0 +1,64 @@
+from ..exceptions import NonorientableManifoldError
+from . import cohomology_fractal
+
+try:
+    from ..gui import ViewerWindow
+    from .inside_viewer import InsideViewer
+except ImportError as e:
+    InsideViewer = None
+    _importErrorRaytracing = str(e)
+
+from typing import Sequence
+
+def inside_view(self, cohomology_class=None, geodesics : Sequence[str]=[]):
+    r"""
+    Show raytraced inside view of hyperbolic manifold. See
+    `images <https://im.icerm.brown.edu/portfolio/snappy-views/>`_
+    and `demo video <https://youtu.be/CAERhmUCkRs>`_.
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view() #doctest: +CYMODERNOPENGL
+
+    Or show the cohomology fractal:
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view(cohomology_class = 0) #doctest: +CYMODERNOPENGL
+
+    The cohomology class in :math:`H^2(M, \partial M; \mathbb{R})` producing the
+    cohomology fractal can be specified as a cocycle or using an automatically
+    computed basis (of, say, length ``n``). Thus, ``cohomology_class`` can be
+    one of the following.
+
+    - An integer ``i`` between 0 and ``n`` - 1 to pick the ``i``-th basis
+      vector.
+    - An array of length ``n`` specifying the cohomology class as linear
+      combination of basis vectors.
+    - A weight for each face of each tetrahedron.
+
+    Geodesics can be specified as words in the unsimplified fundamental group:
+
+        >>> M = Manifold("m004")
+        >>> M.inside_view(geodesics=['a', 'bC']) #doctest: +CYMODERNOPENGL
+
+    """
+
+    if InsideViewer is None:
+        raise RuntimeError("Raytraced inside view not imported; "
+        "Tk or CyOpenGL is probably missing "
+        "(original error : %s)" % _importErrorRaytracing)
+
+    if not self.is_orientable():
+        raise NonorientableManifoldError("Manifold.inside_view", self)
+
+    weights, cohomology_basis, cohomology_class = (
+        cohomology_fractal.compute_weights_basis_class(
+            self, cohomology_class))
+
+    return ViewerWindow(
+        InsideViewer,
+        self,
+        title="Inside view of %s" % self.name(),
+        weights=weights,
+        cohomology_basis=cohomology_basis,
+        cohomology_class=cohomology_class,
+        geodesics=geodesics)

snappy/raytracing/additional_horospheres.py

@@ -0,0 +1,64 @@
+"""
+from snappy import *; from snappy.raytracing.additional_horospheres import *
+
+M=Manifold("t10879")
+M=CubicalOrientableCuspedCensus[0]
+v = M.inside_view()
+a=AdditionalHorospheres(M)
+v.view.widget.additional_structures['horospheres'] = a; v.view.widget._update_shader()
+
+"""
+
+from ..geometric_structure.cusp_neighborhood.tiles_for_cusp_neighborhood import mcomplex_for_tiling_cusp_neighborhoods
+from .pack import pack_tet_data
+from .upper_halfspace_utilities import add_coordinate_transform_to_mcomplex
+
+class AdditionalHorospheres:
+    def __init__(self, manifold):
+
+        self.mcomplex = mcomplex_for_tiling_cusp_neighborhoods(
+            manifold, bits_prec = 53, verified = False)
+        add_coordinate_transform_to_mcomplex(self.mcomplex)
+
+        self.num_tetrahedra = manifold.num_tetrahedra()
+        self.RF = manifold.tetrahedra_shapes('rect')[0].real().parent()
+        self.cusp_areas = [ 1.0 for v in self.mcomplex.Vertices ]
+
+        self._num = 0
+
+        self.compute_bindings()
+        
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
+        else:
+            num = 0
+
+        return { 'num_additional_horospheres' : num }
+
+    def get_uniform_bindings(self):
+        return self._uniform_bindings
+
+    def compute_bindings(self):
+
+        tets_to_data = [ [] for i in range(self.num_tetrahedra) ]
+
+        for cusp_index, v in enumerate(self.mcomplex.Vertices):
+            scale = (self.RF(self.cusp_areas[cusp_index]) / v.cusp_area).sqrt()
+
+            d = scale.log()
+
+            for tile in v.tiles():
+                if tile.lower_bound_distance > d:
+                    break
+
+                tet = tile.lifted_tetrahedron.tet
+                
+                s = (
+                    tet.to_coordinates_in_symmetric_tet * tile.inverse_lifted_geometric_object.defining_vec) / scale
+
+                tets_to_data[tet.Index].append(
+                    { 'Vec' : ('vec4', s),
+                      'CuspIndex' : ('int', cusp_index) })
+                
+        self._uniform_bindings, self._num = pack_tet_data('additionalHorospheres.horosphere', tets_to_data)