passagemath-planarity 10.6.33__cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

passagemath_planarity-10.6.33.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: passagemath-planarity
+Version: 10.6.33
+Summary: passagemath: Graph planarity with the edge addition planarity suite
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: passagemath-graphs
+Provides-Extra: test
+Requires-Dist: passagemath-repl; extra == "test"
+
+========================================================================
+ passagemath: Graph planarity with the edge addition planarity suite
+========================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.13.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-planarity`` is a small
+optional distribution for use with ``passagemath-graphs``.
+
+It provides a Cython interface to the
+`Edge Addition Planarity Suite <https://github.com/graph-algorithms/edge-addition-planarity-suite/>`_
+by John Boyer.
+
+
+What is included
+----------------
+
+- `Cython interface to Boyer's planarity algorithm <https://passagemath.org/docs/latest/html/en/reference/graphs/sage/graphs/planarity.html>`_
+
+
+Examples
+--------
+
+::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-planarity[test]" ipython
+
+    In [1]: from sage.all__sagemath_planarity import *
+
+    In [2]: g = graphs.PetersenGraph()
+
+    In [3]: g.is_planar()
+    Out[3]: False

passagemath_planarity-10.6.33.dist-info/RECORD

@@ -0,0 +1,9 @@
+passagemath_planarity.libs/libplanarity-1caa02de.so.2.0.0,sha256=oxHNikQFcCJ1vwUwACrGFXmPTsS6nqfwS7h9ZyWBrcw,797409
+sage/all__sagemath_planarity.py,sha256=dECwfNACjxwWI9PD5V5iC7MyTSIFTCHmJxryPSf2Cqw,109
+sage/graphs/all__sagemath_planarity.py,sha256=CYZamBzI163p8V2TX9c1rV2S9cGAOxEOhc82QQkpTvQ,48
+sage/graphs/planarity.cpython-314t-aarch64-linux-gnu.so,sha256=hluBKwLjAL3SgeIhrs0GBahyDeLhQHVqwkUGL9L4A2k,856945
+sage/graphs/planarity.pyx,sha256=2OQXReYJKYQ6MjVMO0uAj3I-z_X7fN4nau1aCfe_EUU,7093
+passagemath_planarity-10.6.33.dist-info/METADATA,sha256=jbLLxi-j02xMeppOgAnEkMYlnH8_RSIRkOZA0GMoLQo,4859
+passagemath_planarity-10.6.33.dist-info/WHEEL,sha256=Klc695QJfkUQN6ZiWyj9Y_w-eR82-M5d6Qzo8oOOF4Q,196
+passagemath_planarity-10.6.33.dist-info/top_level.txt,sha256=Kmzulf9WsphADFQuqgvdy5mvTLDj_V2zkFHU2s3UXos,6
+passagemath_planarity-10.6.33.dist-info/RECORD,,

passagemath_planarity-10.6.33.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314t-manylinux_2_17_aarch64
+Tag: cp314-cp314t-manylinux2014_aarch64
+Tag: cp314-cp314t-manylinux_2_28_aarch64
+

passagemath_planarity-10.6.33.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+
+sage

sage/all__sagemath_planarity.py

@@ -0,0 +1,4 @@
+# sage_setup: distribution = sagemath-planarity
+# delvewheel: patch
+
+from sage.all__sagemath_graphs import *

sage/graphs/all__sagemath_planarity.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-planarity

sage/graphs/planarity.pyx

@@ -0,0 +1,191 @@
+# sage_setup: distribution = sagemath-planarity
+# distutils: libraries = planarity
+"""
+Wrapper for Boyer's (C) planarity algorithm
+"""
+
+cdef extern from "planarity/graph.h":
+    ctypedef struct vertexRec:
+        int link[2]
+        int index
+    ctypedef vertexRec * vertexRecP
+
+    ctypedef struct edgeRec:
+        int link[2]
+        int neighbor
+    ctypedef edgeRec * edgeRecP
+
+    ctypedef struct BM_graph:
+        vertexRecP V
+        edgeRecP E
+        int N
+    ctypedef BM_graph * graphP
+
+    cdef int OK, EMBEDFLAGS_PLANAR, NONEMBEDDABLE, NOTOK
+
+    cdef graphP gp_New()
+    cdef void gp_Free(graphP *pGraph)
+    cdef int gp_InitGraph(graphP theGraph, int N)
+    cdef int gp_AddEdge(graphP theGraph, int u, int ulink, int v, int vlink)
+    cdef int gp_Embed(graphP theGraph, int embedFlags)
+    cdef int gp_SortVertices(graphP theGraph)
+
+
+def is_planar(g, kuratowski=False, set_pos=False, set_embedding=False):
+    r"""
+    Check whether ``g`` is planar using Boyer's planarity algorithm.
+
+    If ``kuratowski`` is ``False``, returns ``True`` if ``g`` is planar,
+    ``False`` otherwise.  If ``kuratowski`` is ``True``, returns a tuple, first
+    entry is a boolean (whether or not the graph is planar) and second entry is
+    a Kuratowski subgraph, i.e. an edge subdivision of `K_5` or `K_{3,3}` (if
+    not planar) or ``None`` (if planar).  Also, will set an ``_embedding``
+    attribute for the graph ``g`` if ``set_embedding`` is set to ``True``.
+
+    INPUT:
+
+    - ``kuratowski`` -- boolean (default: ``False``); when set to ``True``,
+      return a tuple of a boolean and either ``None`` or a Kuratowski subgraph
+      (i.e. an edge subdivision of `K_5` or `K_{3,3}`). When set to ``False``,
+      returns ``True`` if ``g`` is planar, ``False`` otherwise.
+
+    - ``set_pos`` -- boolean (default: ``False``); whether to use Schnyder's
+      algorithm to determine and set positions
+
+    - ``set_embedding`` -- boolean (default: ``False``); whether to record the
+      combinatorial embedding returned (see
+      :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding`)
+
+    EXAMPLES::
+
+        sage: G = graphs.DodecahedralGraph()
+        sage: from sage.graphs.planarity import is_planar
+        sage: is_planar(G)
+        True
+        sage: Graph('@').is_planar()
+        True
+
+    TESTS:
+
+    We try checking the planarity of all graphs on 7 or fewer
+    vertices.  In fact, to try to track down a segfault, we do it
+    twice. ::
+
+        sage: # long time, needs networkx
+        sage: import networkx.generators.atlas
+        sage: atlas_graphs = [Graph(i) for i in networkx.generators.atlas.graph_atlas_g()]
+        sage: a = [i for i in [1..1252] if atlas_graphs[i].is_planar()]
+        sage: b = [i for i in [1..1252] if atlas_graphs[i].is_planar()]
+        sage: a == b
+        True
+
+    There were some problems with ``set_pos`` stability in the past,
+    so let's check if this runs without exception::
+
+        sage: for i, g in enumerate(atlas_graphs):      # long time                     # needs networkx
+        ....:     if (not g.is_connected() or i == 0):
+        ....:         continue
+        ....:     _ = g.is_planar(set_embedding=True, set_pos=True)
+
+        Argument saving::
+
+            sage: G = Graph([(1, 2)])
+            sage: for set_embedding, set_pos in ((True,True), (True,False), (False, True), (False, False)):
+            ....:     G = Graph([(1, 2)])
+            ....:     assert is_planar(G, set_embedding=set_embedding, set_pos=set_pos)
+            ....:     assert (hasattr(G, '_embedding') and G._embedding is not None) == set_embedding, (set_embedding, set_pos)
+            ....:     assert (hasattr(G, '_pos') and G._pos is not None) == set_pos, (set_embedding, set_pos)
+    """
+    g._scream_if_not_simple()
+    if set_pos and not g.is_connected():
+        raise ValueError("is_planar() cannot set vertex positions for a disconnected graph")
+
+    # First take care of a trivial cases
+    if not g.size():
+        # There are no edges
+        if set_embedding:
+            g._embedding = {v: [] for v in g}
+        return (True, None) if kuratowski else True
+    if g.order() == 2 and g.is_connected():
+        # P_2 is too small to be triangulated
+        u, v = list(g)
+        if set_embedding:
+            g._embedding = {u: [v], v: [u]}
+        if set_pos:
+            g._pos = {u: [0, 0], v: [0, 1]}
+        return (True, None) if kuratowski else True
+
+    # Create to and from mappings to relabel vertices to the set {1,...,n}
+    # (planarity 3 uses 1-based array indexing, with 0 representing NIL)
+    cdef int i
+    cdef list listto = list(g)
+    cdef dict ffrom = {vvv: i for i, vvv in enumerate(listto, start=1)}
+    cdef dict to = {i: vvv for i, vvv in enumerate(listto, start=1)}
+
+    cdef graphP theGraph
+    theGraph = gp_New()
+    cdef int status
+    status = gp_InitGraph(theGraph, g.order())
+    if status != OK:
+        raise RuntimeError("gp_InitGraph status is not ok")
+    for u, v in g.edge_iterator(labels=False):
+        status = gp_AddEdge(theGraph, ffrom[u], 0, ffrom[v], 0)
+        if status == NOTOK:
+            raise RuntimeError("gp_AddEdge status is not ok")
+        elif status == NONEMBEDDABLE:
+            # We now know that the graph is nonplanar.
+            if not kuratowski:
+                gp_Free(&theGraph)
+                return False
+            # With just the current edges, we have a nonplanar graph,
+            # so to isolate a kuratowski subgraph, just keep going.
+            break
+
+    status = gp_Embed(theGraph, EMBEDFLAGS_PLANAR)
+
+    if status == NOTOK:
+        raise RuntimeError("status is not ok")
+
+    gp_SortVertices(theGraph)
+
+    if status == NONEMBEDDABLE:
+        # Kuratowski subgraph isolator
+        if not kuratowski:
+            gp_Free(&theGraph)
+            return False
+        g_dict = {}
+        for i in range(1, theGraph.N + 1):
+            linked_list = []
+            j = theGraph.V[i].link[1]
+            while j:
+                linked_list.append(to[theGraph.E[j].neighbor])
+                j = theGraph.E[j].link[1]
+            if linked_list:
+                g_dict[to[i]] = linked_list
+        gp_Free(&theGraph)
+        G = g.__class__(data=g_dict, weighted=g._weighted,
+                        loops=g.allows_loops(),
+                        multiedges=g.allows_multiple_edges(),
+                        name="Kuratowski subgraph of (%s)" % g.name())
+        if g.get_pos():
+            G.set_pos({u: g._pos[u] for u in g_dict})
+        return (False, G)
+
+    if set_pos or set_embedding:
+        emb_dict = {}
+        for i in range(1, theGraph.N + 1):
+            linked_list = []
+            j = theGraph.V[i].link[1]
+            while j:
+                linked_list.append(to[theGraph.E[j].neighbor])
+                j = theGraph.E[j].link[1]
+            emb_dict[to[i]] = linked_list
+        if set_embedding:
+            g._embedding = emb_dict
+        if set_pos:
+            g.layout(layout='planar', save_pos=True, on_embedding=emb_dict)
+
+    gp_Free(&theGraph)
+    if kuratowski:
+        return (True, None)
+    return True