passagemath-graphs 10.5.48__cp310-cp310-musllinux_1_2_aarch64.whl → 10.6.1__cp310-cp310-musllinux_1_2_aarch64.whl

sage/graphs/traversals.pyx

@@ -63,7 +63,6 @@ Methods
 
 from collections import deque
 
-from libc.string cimport memset
 from libc.stdint cimport uint32_t
 from libcpp.vector cimport vector
 from cysignals.signals cimport sig_on, sig_off
@@ -75,7 +74,6 @@ from sage.graphs.base.static_sparse_backend cimport StaticSparseCGraph
 from sage.graphs.base.static_sparse_backend cimport StaticSparseBackend
 from sage.graphs.base.static_sparse_graph cimport init_short_digraph
 from sage.graphs.base.static_sparse_graph cimport free_short_digraph
-from sage.graphs.base.static_sparse_graph cimport out_degree
 from sage.graphs.graph_decompositions.slice_decomposition cimport \
         extended_lex_BFS
 
@@ -465,6 +463,14 @@ def lex_BFS(G, reverse=False, tree=False, initial_vertex=None, algorithm="fast")
         Traceback (most recent call last):
         ...
         ValueError: 'foo' is not a graph vertex
+
+    Check that :issue:`39934` is fixed::
+
+        sage: G = Graph(1, immutable=True)
+        sage: G.lex_BFS(algorithm='slow')
+        [0]
+        sage: G.lex_BFS(algorithm='fast')
+        [0]
     """
     if initial_vertex is not None and initial_vertex not in G:
         raise ValueError(f"'{initial_vertex}' is not a graph vertex")
@@ -475,22 +481,15 @@ def lex_BFS(G, reverse=False, tree=False, initial_vertex=None, algorithm="fast")
     if algorithm != "fast":
         raise ValueError(f"unknown algorithm '{algorithm}'")
 
-    cdef size_t n = G.order()
-
     # For algorithm "fast" we need to convert G to an undirected graph
     if G.is_directed():
         G = G.to_undirected()
 
-    # Initialize variables needed by the fast and slow algorithms
+    # Initialize variables needed by the fast algorithm
     cdef CGraphBackend Gbackend = <CGraphBackend> G._backend
     cdef CGraph cg = Gbackend.cg()
-    cdef list sigma = []
-    cdef dict predecessor = {}
-    # Initialize variables needed by the fast algorithm
     cdef vector[int] sigma_int
     cdef vector[int] pred
-    # Initialize variables needed by the slow algorithm
-    cdef dict lexicographic_label
     # Temporary variables
     cdef int vi, i, initial_v_int
 
@@ -500,9 +499,11 @@ def lex_BFS(G, reverse=False, tree=False, initial_vertex=None, algorithm="fast")
         initial_v_int = Gbackend.get_vertex(initial_vertex)
     else:
         initial_v_int = -1
+    sig_on()
     extended_lex_BFS(cg, sigma_int, NULL, initial_v_int, &pred, NULL, NULL)
-    sigma = [ Gbackend.vertex_label(vi) for vi in sigma_int ]
-    predecessor = { u: sigma[i] for u, i in zip(sigma, pred) if i != -1 }
+    sig_off()
+    cdef list sigma = [Gbackend.vertex_label(vi) for vi in sigma_int]
+    cdef dict predecessor = {u: sigma[i] for u, i in zip(sigma, pred) if i != -1}
 
     if reverse:
         sigma.reverse()

sage/graphs/tutte_polynomial.py

@@ -663,7 +663,7 @@ def _tutte_polynomial_internal(G, x, y, edge_selector, cache=None):
     ##################################
 
     # Theorem 4: from Haggard, Pearce, and Royle Note that the formula
-    # at http://homepages.ecs.vuw.ac.nz/~djp/files/TOMS10.pdf is
+    # at https://web.archive.org/web/20110401195911/http://homepages.ecs.vuw.ac.nz/~djp/files/TOMS10.pdf is
     # slightly incorrect.  The initial sum should only go to n-2
     # instead of n (allowing for the last part of the recursion).
     # Additionally, the first operand of the final product should be

sage/graphs/views.pyx

@@ -786,7 +786,7 @@ cdef class EdgesView:
             sage: E * 1.5
             Traceback (most recent call last):
             ...
-            TypeError: can...t multiply sequence by non-int of type 'sage.rings.real_mpfr.RealLiteral'
+            TypeError: can...t multiply sequence by non-int of type 'sage.rings.real...'
         """
         if isinstance(left, EdgesView):
             return list(left) * right

sage/graphs/weakly_chordal.pyx

@@ -38,6 +38,8 @@ Methods
 
 from memory_allocator cimport MemoryAllocator
 from sage.data_structures.bitset_base cimport *
+from sage.graphs.base.static_sparse_backend cimport StaticSparseCGraph
+from sage.graphs.base.static_sparse_backend cimport StaticSparseBackend
 from sage.graphs.base.static_sparse_graph cimport short_digraph
 from sage.graphs.base.static_sparse_graph cimport init_short_digraph
 from sage.graphs.base.static_sparse_graph cimport free_short_digraph
@@ -200,6 +202,17 @@ def is_long_hole_free(g, certificate=False):
 
         sage: graphs.EmptyGraph().is_long_hole_free()
         True
+
+    Immutable graphs::
+
+        sage: G = graphs.RandomGNP(10, .7)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = Graph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: G.is_long_hole_free() == H.is_long_hole_free()
+        True
     """
     g._scream_if_not_simple()
 
@@ -212,9 +225,16 @@ def is_long_hole_free(g, certificate=False):
     # documented in the module sage.graphs.base.static_sparse_graph.
     # Vertices are relabeled in 0..n-1
     cdef int n = g.order()
-    cdef list id_label = list(g)
+    cdef list id_label
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
-    init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
+    if isinstance(g, StaticSparseBackend):
+        cg = <StaticSparseCGraph> g._cg
+        sd = <short_digraph> cg.g
+        id_label = cg._vertex_to_labels
+    else:
+        id_label = list(g)
+        init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
 
     # Make a dense copy of the graph for quick adjacency tests
     cdef bitset_t dense_graph
@@ -258,7 +278,8 @@ def is_long_hole_free(g, certificate=False):
 
                     if not res:
                         # We release memory before returning the result
-                        free_short_digraph(sd)
+                        if not isinstance(g, StaticSparseBackend):
+                            free_short_digraph(sd)
                         bitset_free(dense_graph)
 
                         if certificate:
@@ -269,7 +290,8 @@ def is_long_hole_free(g, certificate=False):
         InPath[u] = -1
 
     # Release memory
-    free_short_digraph(sd)
+    if not isinstance(g, StaticSparseBackend):
+        free_short_digraph(sd)
     bitset_free(dense_graph)
 
     if certificate:
@@ -428,6 +450,17 @@ def is_long_antihole_free(g, certificate=False):
 
         sage: graphs.EmptyGraph().is_long_hole_free()
         True
+
+    Immutable graphs::
+
+        sage: G = graphs.RandomGNP(10, .7)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = Graph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: G.is_long_antihole_free() == H.is_long_antihole_free()
+        True
     """
     g._scream_if_not_simple()
 
@@ -440,9 +473,16 @@ def is_long_antihole_free(g, certificate=False):
     # documented in the module sage.graphs.base.static_sparse_graph.
     # Vertices are relabeled in 0..n-1
     cdef int n = g.order()
-    cdef list id_label = list(g)
+    cdef list id_label
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
-    init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
+    if isinstance(g, StaticSparseBackend):
+        cg = <StaticSparseCGraph> g._cg
+        sd = <short_digraph> cg.g
+        id_label = cg._vertex_to_labels
+    else:
+        id_label = list(g)
+        init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
 
     # Make a dense copy of the graph for quick adjacency tests
     cdef bitset_t dense_graph
@@ -487,7 +527,8 @@ def is_long_antihole_free(g, certificate=False):
 
                     if not res:
                         # We release memory before returning the result
-                        free_short_digraph(sd)
+                        if not isinstance(g, StaticSparseBackend):
+                            free_short_digraph(sd)
                         bitset_free(dense_graph)
 
                         if certificate:
@@ -498,7 +539,8 @@ def is_long_antihole_free(g, certificate=False):
         InPath[u] = -1
 
     # Release memory
-    free_short_digraph(sd)
+    if not isinstance(g, StaticSparseBackend):
+        free_short_digraph(sd)
     bitset_free(dense_graph)
 
     if certificate:

sage/knots/free_knotinfo_monoid.py

@@ -16,15 +16,15 @@ AUTHORS:
 - Sebastian Oehms June 2024: initial version
 """
 
-##############################################################################
+# ############################################################################
 #       Copyright (C) 2024 Sebastian Oehms <seb.oehms@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.
-#                  http://www.gnu.org/licenses/
-##############################################################################
+#                  https://www.gnu.org/licenses/
+# ############################################################################
 
 from sage.knots.knotinfo import SymmetryMutant
 from sage.monoids.indexed_free_monoid import (IndexedFreeAbelianMonoid,