passagemath-polyhedra 10.6.37__cp314-cp314-musllinux_1_2_x86_64.whl

sage/geometry/polyhedron/combinatorial_polyhedron/face_data_structure.pxd

@@ -0,0 +1,207 @@
+# sage_setup: distribution = sagemath-polyhedra
+"""
+Cython data structure for combinatorial faces.
+"""
+# ****************************************************************************
+#       Copyright (C) 2020 Jonathan Kliem <jonathan.kliem@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from memory_allocator                 cimport MemoryAllocator
+from sage.data_structures.bitset_base cimport *
+
+ctypedef int simple
+ctypedef long standard
+
+cdef struct face_s:
+    sparse_bitset_t atoms
+    bitset_t coatoms
+
+ctypedef face_s face_t[1]
+
+ctypedef fused algorithm_variant:
+    simple
+    standard
+
+#############################################################################
+# Face Initialization
+#############################################################################
+
+cdef inline bint face_init(face_t face, mp_bitcnt_t n_atoms, mp_bitcnt_t n_coatoms) except -1:
+    """
+    Initialize and clear ``face``.
+    """
+    if n_coatoms == 0:
+        # Special case for trivial polyhedra.
+        n_coatoms += 1
+    if n_atoms == 0:
+        n_atoms += 1
+    bitset_init(face.atoms, n_atoms)
+    bitset_init(face.coatoms, n_coatoms)
+
+cdef inline void face_free(face_t face) noexcept:
+    """
+    Free ``face``.
+    """
+    bitset_free(face.atoms)
+    bitset_free(face.coatoms)
+
+cdef inline bint face_check_alignment(face_t face) noexcept:
+    """
+    Return whether the data is correctly aligned.
+    """
+    return bitset_check_alignment(face.atoms)
+
+cdef inline void face_clear(face_t face) noexcept:
+    """
+    Remove all atoms and coatoms from face.
+    """
+    bitset_clear(face.atoms)
+    bitset_clear(face.coatoms)
+
+cdef inline void face_copy(face_t dst, face_t src) noexcept:
+    """
+    Copy src to dst overwriting dst.
+
+    dst may contain more atoms and coatoms, but not less.
+    """
+    bitset_copy_flex(dst.atoms, src.atoms)
+    bitset_copy_flex(dst.coatoms, src.coatoms)
+
+
+#############################################################################
+# Face Comparison
+#############################################################################
+
+cdef inline bint face_isempty(face_t face) noexcept nogil:
+    """
+    Return whether ``face`` contains no coatoms.
+    """
+    return bitset_isempty(face.atoms)
+
+cdef inline int face_cmp(face_t a, face_t b) noexcept:
+    """
+    Return ``0`` if the faces are equal and consistently
+    ``-1`` and ``1`` if not.
+    """
+    return bitset_cmp(a.atoms, b.atoms)
+
+cdef inline bint face_issubset_fused(face_t a, face_t b, algorithm_variant algorithm) noexcept nogil:
+    """
+    Return whether ``a`` is a subface of ``b``.
+    """
+    if algorithm_variant is standard:
+        return bitset_issubset(a.atoms, b.atoms)
+    else:
+        return bitset_issuperset(a.coatoms, b.coatoms)
+
+cdef inline bint face_issubset(face_t a, face_t b) noexcept nogil:
+    return face_issubset_fused(a, b, <standard> 0)
+
+#############################################################################
+# Face Bit Manipulation
+#############################################################################
+
+cdef inline bint face_atom_in(face_t face, mp_bitcnt_t n) noexcept:
+    """
+    Return whether ``n`` is an atom of ``face``.
+    """
+    return bitset_in(face.atoms, n)
+
+cdef inline void face_add_atom(face_t face, mp_bitcnt_t n) noexcept:
+    """
+    Add atom `n` to the face.
+    """
+    bitset_add(face.atoms, n)
+
+cdef inline int face_add_atom_safe(face_t face, mp_bitcnt_t n) except -1:
+    """
+    Add atom `n` to the face.
+    """
+    if (n > face.atoms.size):
+        raise KeyError(n)
+    bitset_add(face.atoms, n)
+
+cdef inline void face_discard_atom(face_t face, mp_bitcnt_t n) noexcept:
+    """
+    Discard atom `n` of the face.
+    """
+    bitset_discard(face.atoms, n)
+
+cdef inline void facet_set_coatom(face_t face, mp_bitcnt_t n) noexcept:
+    """
+    Set the facet to be coatom ``n``.
+    """
+    bitset_clear(face.coatoms)
+    bitset_add(face.coatoms, n)
+
+cdef inline void face_set_first_n_atoms(face_t face, mp_bitcnt_t n) noexcept:
+    """
+    Set exactly the first ``n`` atoms.
+    """
+    bitset_set_first_n(face.atoms, n)
+
+
+#############################################################################
+# Face Searching
+#############################################################################
+
+cdef inline long face_next_atom(face_t face, mp_bitcnt_t n) noexcept:
+    """
+    Return the index of the next atom in ``face`` with index >= ``n``.
+
+    In case there are none, return ``-1``.
+    """
+    return bitset_next(face.atoms, n)
+
+cdef inline long face_first_missing_atom(face_t face) noexcept:
+    """
+    Return the index of the first atom not in ``face``.
+
+    In case there are none, return ``-1``.
+    """
+    return bitset_first_in_complement(face.atoms)
+
+cdef inline long face_len_atoms(face_t face) noexcept nogil:
+    """
+    Calculate the number of atoms in the face.
+    """
+    return bitset_len(face.atoms)
+
+
+#############################################################################
+# Arithmetic
+#############################################################################
+
+cdef inline void face_intersection_fused(face_t dest, face_t A, face_t B, algorithm_variant algorithm) noexcept nogil:
+    """
+    Set ``dest`` to the intersection of ``A`` and ``B``.
+    """
+    if algorithm_variant is standard:
+        # Also setting the nonzero positions.
+        sparse_bitset_intersection(dest.atoms, A.atoms, B.atoms)
+    else:
+        bitset_intersection(dest.atoms, A.atoms, B.atoms)
+        bitset_union(dest.coatoms, A.coatoms, B.coatoms)
+
+cdef inline void face_intersection(face_t dest, face_t A, face_t B) noexcept nogil:
+    face_intersection_fused(dest, A, B, <standard> 0)
+
+
+#############################################################################
+# Miscellaneous
+#############################################################################
+
+cdef inline void swap_faces(face_t a, face_t b) noexcept nogil:
+    cdef face_t tmp
+    tmp[0] = a[0]
+    a[0] = b[0]
+    b[0] = tmp[0]
+
+cdef inline bint faces_are_identical(face_t a, face_t b) noexcept nogil:
+    return a.atoms.limbs == b.atoms.limbs

sage/geometry/polyhedron/combinatorial_polyhedron/face_iterator.pxd

@@ -0,0 +1,102 @@
+# sage_setup: distribution = sagemath-polyhedra
+cimport cython
+from sage.structure.sage_object cimport SageObject
+from sage.geometry.polyhedron.combinatorial_polyhedron.list_of_faces             cimport ListOfFaces
+from sage.geometry.polyhedron.combinatorial_polyhedron.face_data_structure       cimport face_t
+from sage.geometry.polyhedron.combinatorial_polyhedron.face_list_data_structure  cimport face_list_t
+from sage.geometry.polyhedron.combinatorial_polyhedron.combinatorial_face        cimport CombinatorialFace
+
+cdef enum FaceStatus:
+    NOT_INITIALIZED
+    INITIALIZED
+    IGNORE_SUBSETS
+    ONLY_VISIT_SUBSETS
+
+cdef struct iter_s:
+    bint dual                  # if 1, then iterate over dual Polyhedron
+    face_t face                # the current face of the iterator
+    FaceStatus face_status
+    size_t *atom_rep           # a place where atom-representation of face will be stored
+    size_t *coatom_rep         # a place where coatom-representation of face will be stored
+    int current_dimension      # dimension of current face, dual dimension if ``dual``
+    int dimension              # dimension of the polyhedron
+    int output_dimension       # only faces of this (dual?) dimension are considered
+    int lowest_dimension       # don't consider faces below this (dual?) dimension
+    int highest_dimension      # don't consider faces above this (dual?) dimension
+    size_t _index              # this counts the number of seen faces, useful for hasing the faces
+
+    # ``visited_all`` points to faces, of which we have visited all faces already.
+    # The number of faces in ``visited_all`` might depend on the current dimension:
+    #     Consider we visit the facets A,B of some face F.
+    #     We will first visit all faces of A and then add A to visited_all.
+    #     Then we visit all faces of B and add B to visited_all.
+    #     Then we have visited F completely.
+    #     Instead of having A and B in ``visited_all`` we will point to F.
+    #     In this way, we will append ``visited_all`` in lower dimension, but
+    #     will ignore those changes when going up in dimension again.
+    #     This is why the number of faces in ``visited_all``depends on dimension.
+    face_list_t* visited_all
+
+    # ``new_faces`` is where the new faces are stored.
+    # Needs to be long enough to store all possible intersections of a face with all coatoms.
+    face_list_t* new_faces
+
+    # After having visited a face completely, we want to add it to ``visited_all``.
+    # ``first_time[i]`` will indicate, whether there is one more face in
+    # ``newfaces[i]`` then ``n_newfaces[i]`` suggests
+    # that has to be added to ``visited_all``.
+    # If ``first_time[i] == False``, we still need to
+    # add ``newfaces[i][n_newfaces[i]]`` to ``visited_all``.
+    bint *first_time
+
+    # The number of elements in newfaces[current_dimension],
+    # that have not been visited yet.
+    size_t yet_to_visit
+    size_t n_coatoms
+
+ctypedef iter_s iter_t[1]
+
+
+cdef class FaceIterator_base(SageObject):
+    cdef iter_t structure
+    cdef readonly bint dual         # if 1, then iterate over dual Polyhedron
+
+    # some copies from ``CombinatorialPolyhedron``
+    cdef tuple _Vrep, _facet_names, _equations
+    cdef size_t _n_equations, _n_facets
+    cdef bint _bounded
+    cdef face_t _far_face
+
+    # Atoms and coatoms are the vertices/facets of the Polyedron.
+    # If ``dual == 0``, then coatoms are facets, atoms vertices and vice versa.
+    cdef ListOfFaces atoms, coatoms, coatoms_coatom_rep
+
+    cdef inline CombinatorialFace next_face(self)
+    cdef inline int next_dimension(self) except -1
+    cdef inline int next_face_loop(self) except -1
+    cdef size_t n_atom_rep(self) except -1
+    cdef size_t set_coatom_rep(self) except -1
+    cdef size_t set_atom_rep(self) except -1
+    cdef int ignore_subsets(self) except -1
+    cdef int only_subsets(self) except -1
+    cdef int find_face(self, face_t face) except -1
+
+
+@cython.final
+cdef class FaceIterator(FaceIterator_base):
+    pass
+
+
+@cython.final
+cdef class FaceIterator_geom(FaceIterator_base):
+    cdef int _trivial_faces     # Whether to yield the trivial faces.
+    cdef object _requested_dim  # Dimension requested on init.
+    cdef readonly object P      # The original polyhedron.
+
+cdef int parallel_f_vector(iter_t* structures, size_t num_threads, size_t parallelization_depth, size_t *f_vector) except -1
+
+# Nogil definitions of crucial functions.
+
+cdef int next_dimension(iter_t structure, size_t parallelization_depth=?) except -1 nogil
+cdef int next_face_loop(iter_t structure) except -1 nogil
+cdef size_t n_atom_rep(iter_t structure) except -1 nogil