Ticket #14589: trac_14589.patch

doc/en/reference/graphs/index.rst

@@ -38 +38 @@
    sage/graphs/base/sparse_graph
    sage/graphs/base/dense_graph
    sage/graphs/base/static_sparse_graph
+   sage/graphs/base/static_dense_graph
    sage/graphs/base/graph_backends
 
 Hypergraphs

module_list.py

@@ -383 +383 @@
     Extension('sage.graphs.base.static_sparse_graph',
               sources = ['sage/graphs/base/static_sparse_graph.pyx']),
 
+    Extension('sage.graphs.base.static_dense_graph',
+              sources = ['sage/graphs/base/static_dense_graph.pyx']),
+
     Extension('sage.graphs.modular_decomposition.modular_decomposition',
               sources = ['sage/graphs/modular_decomposition/modular_decomposition.pyx',
                          'sage/graphs/modular_decomposition/src/dm.c'],

sage/graphs/base/all.py

@@ -1 +1 @@
 from sparse_graph import SparseGraph
 from dense_graph import DenseGraph
 import sage.graphs.base.static_sparse_graph
+import sage.graphs.base.static_dense_graph

new file sage/graphs/base/static_dense_graph.pyx

@@ +1 @@
+r"""
+Static dense graphs
+
+This module gathers everything which is related to static dense graphs, i.e. :
+
+- The vertices are integer from `0` to `n-1`
+- No labels on vertices/edges
+- No multiple edges
+- No addition/removal of vertices
+
+This being said, it is technically possible to add/remove edges. The data
+structure does not mind at all.
+
+It is all based on the binary matrix data structure described in
+``misc/binary_matrix.pxi``, which is almost a copy of the bitset data
+structure. The only difference is that it differentiates the rows (the vertices)
+instead of storing the whole data in a long bitset, and we can use that.
+
+Index
+-----
+
+**Cython functions**
+
+.. csv-table::
+    :class: contentstable
+    :widths: 30, 70
+    :delim: |
+
+    ``dense_graph_init`` | Fills a binary matrix with the information of a (di)graph.
+
+**Python functions**
+
+.. csv-table::
+    :class: contentstable
+    :widths: 30, 70
+    :delim: |
+
+    :meth:`is_strongly_regular` | Tests if a graph is strongly regular
+
+Functions
+---------
+"""
+include "sage/misc/binary_matrix.pxi"
+
+cdef dict dense_graph_init(binary_matrix_t m, g, translation = False):
+    r"""
+    Initializes the binary matrix from a Sage (di)graph.
+
+    INPUT:
+
+    - ``binary_matrix_t m`` -- the binary matrix to be filled
+
+    - ``g`` -- a graph or digraph
+
+    - ``translation`` (boolean) -- whether to return a dictionary associating to
+      each vertex its corresponding integer in the binary matrix.
+    """
+    cdef dict d_translation
+    from sage.graphs.graph import Graph
+    cdef int is_undirected = isinstance(g, Graph)
+    cdef int n = g.order()
+
+    binary_matrix_init(m,n,n)
+    binary_matrix_fill(m,0)
+
+    # If the vertices are 0...n-1, let's avoid an unnecessary dictionary
+    if g.vertices() == range(n):
+        if translation:
+            d_translation = {i:i for i in range(n)}
+
+        for i,j in g.edge_iterator(labels = False):
+            binary_matrix_set1(m,i,j)
+            if is_undirected:
+                binary_matrix_set1(m,j,i)
+    else:
+        d_translation = {v:i for i,v in enumerate(g.vertices())}
+
+        for u,v in g.edge_iterator(labels = False):
+            binary_matrix_set1(m,d_translation[u],d_translation[v])
+            if is_undirected:
+                binary_matrix_set1(m,d_translation[v],d_translation[u])
+
+    if translation:
+        return d_translation
+
+def is_strongly_regular(g, parameters = False):
+    r"""
+    Tests whether ``self`` is strongly regular.
+
+    A graph `G` is said to be strongly regular with parameters `(n, k, \lambda,
+    \mu)` if and only if:
+
+        * `G` has `n` vertices.
+
+        * `G` is `k`-regular.
+
+        * Any two adjacent vertices of `G` have `\lambda` common neighbors.
+
+        * Any two non-adjacent vertices of `G` have `\mu` common neighbors.
+
+    By convention, the complete graphs, the graphs with no edges
+    and the empty graph are not strongly regular.
+
+    See :wikipedia:`Strongly regular graph`
+
+    INPUT:
+
+    - ``parameters`` (boolean) -- whether to return the quadruple `(n,
+      k,\lambda,\mu)`. If ``parameters = False`` (default), this method only
+      returns ``True`` and ``False`` answers. If ``parameters=True``, the
+      ``True`` answers are replaced by quadruples `(n, k,\lambda,\mu)`. See
+      definition above.
+
+    EXAMPLES:
+
+    Petersen's graph is strongly regular::
+
+        sage: g = graphs.PetersenGraph()
+        sage: g.is_strongly_regular()
+        True
+        sage: g.is_strongly_regular(parameters = True)
+        (10, 3, 0, 1)
+
+    And Clebsch's graph is too::
+
+        sage: g = graphs.ClebschGraph()
+        sage: g.is_strongly_regular()
+        True
+        sage: g.is_strongly_regular(parameters = True)
+        (16, 5, 0, 2)
+
+    But Chvatal's graph is not::
+
+        sage: g = graphs.ChvatalGraph()
+        sage: g.is_strongly_regular()
+        False
+
+    Complete graphs are not strongly regular. (:trac:`14297`) ::
+
+        sage: g = graphs.CompleteGraph(5)
+        sage: g.is_strongly_regular()
+        False
+
+    Completements of complete graphs are not strongly regular::
+
+        sage: g = graphs.CompleteGraph(5).complement()
+        sage: g.is_strongly_regular()
+        False
+
+    The empty graph is not strongly regular::
+
+        sage: g = graphs.EmptyGraph()
+        sage: g.is_strongly_regular()
+        False
+    """
+    cdef binary_matrix_t m
+    cdef int n = g.order()
+    cdef int inter
+    cdef int i,j,l, k
+
+    if g.size() == 0: # no vertices or no edges
+        return False
+
+    if g.is_clique():
+        return False
+
+    cdef list degree = g.degree()
+    k = degree[0]
+    if not all(d == k for d in degree):
+        return False
+
+    # m i now our copy of the graph
+    dense_graph_init(m, g)
+
+    cdef int llambda = -1
+    cdef int mu = -1
+
+    for i in range(n):
+        for j in range(i+1,n):
+
+            # The intersection of the common neighbors of i and j is a AND of
+            # their respective rows. A popcount then returns its cardinality.
+            inter = 0
+            for l in range(m.width):
+                inter += __builtin_popcountl(m.rows[i][l] & m.rows[j][l])
+
+            # Check that this cardinality is correct according to the values of lambda and mu
+            if binary_matrix_get(m,i,j):
+                if llambda == -1:
+                    llambda = inter
+                elif llambda != inter:
+                    binary_matrix_free(m)
+                    return False
+            else:
+                if mu == -1:
+                    mu = inter
+                elif mu != inter:
+                    binary_matrix_free(m)
+                    return False
+
+    binary_matrix_free(m)
+
+    if parameters:
+        return (n,k,llambda,mu)
+    else:
+        return True

sage/graphs/graph.py

@@ -2452 +2452 @@
 
         return self_complement.is_odd_hole_free(certificate = certificate)
 
-    def is_strongly_regular(self, parameters=False):
-        r"""
-        Tests whether ``self`` is strongly regular.
-
-        A graph `G` is said to be strongly regular with parameters (n, k,
-        \lambda, \mu)` if and only if:
-
-            * `G` has `n` vertices.
-
-            * `G` is `k`-regular.
-
-            * Any two adjacent vertices of `G` have `\lambda` common neighbors.
-
-            * Any two non-adjacent vertices of `G` have `\mu` common neighbors.
-
-        By convention, the complete graphs, the graphs with no edges
-        and the empty graph are not strongly regular.
-
-        See :wikipedia:`Strongly regular graph`
-
-        INPUT:
-
-        - ``parameters`` (boolean) -- whether to return the quadruple `(n,
-          k,\lambda,\mu)`. If ``parameters = False`` (default), this method only
-          returns ``True`` and ``False`` answers. If ``parameters=True``, the
-          ``True`` answers are replaced by quadruples `(n, k,\lambda,\mu)`. See
-          definition above.
-
-        EXAMPLES:
-
-        Petersen's graph is strongly regular::
-
-            sage: g = graphs.PetersenGraph()
-            sage: g.is_strongly_regular()
-            True
-            sage: g.is_strongly_regular(parameters = True)
-            (10, 3, 0, 1)
-
-        And Clebsch's graph is too::
-
-            sage: g = graphs.ClebschGraph()
-            sage: g.is_strongly_regular()
-            True
-            sage: g.is_strongly_regular(parameters = True)
-            (16, 5, 0, 2)
-
-        But Chvatal's graph is not::
-
-            sage: g = graphs.ChvatalGraph()
-            sage: g.is_strongly_regular()
-            False
-
-        Complete graphs are not strongly regular. (:trac:`14297`) ::
-
-            sage: g = graphs.CompleteGraph(5)
-            sage: g.is_strongly_regular()
-            False
-
-        Completements of graphs are not strongly regular::
-
-            sage: g = graphs.CompleteGraph(5).complement()
-            sage: g.is_strongly_regular()
-            False
-
-        The empty graph is not strongly regular::
-
-            sage: g = graphs.EmptyGraph()
-            sage: g.is_strongly_regular()
-            False
-        """
-
-        if self.size() == 0: # no vertices or no edges
-            return False
-
-        degree = self.degree()
-        k = degree[0]
-        if not all(d == k for d in degree):
-            return False
-
-        if self.is_clique():
-            return False
-        else:
-            l = m = None
-            for u in self:
-                nu = set(self.neighbors(u))
-                for v in self:
-                    if u == v:
-                        continue
-                    nv = set(self.neighbors(v))
-                    inter = len(nu&nv)
-
-                    if v in nu:
-                        if l is None:
-                            l = inter
-                        else:
-                            if l != inter:
-                                return False
-                    else:
-                        if m is None:
-                            m = inter
-                        else:
-                            if m != inter:
-                                return False
-
-        if parameters:
-            return (self.order(),k,l,m)
-        else:
-            return True
-
     def odd_girth(self):
         r"""
         Returns the odd girth of self.
@@ -6114 +6005 @@
 import sage.graphs.graph_decompositions.graph_products
 Graph.is_cartesian_product = types.MethodType(sage.graphs.graph_decompositions.graph_products.is_cartesian_product, None, Graph)
 
+import sage.graphs.base.static_dense_graph
+Graph.is_strongly_regular = types.MethodType(sage.graphs.base.static_dense_graph.is_strongly_regular, None, Graph)
+
 # From Python modules
 import sage.graphs.line_graph
 Graph.is_line_graph = sage.graphs.line_graph.is_line_graph

new file sage/misc/binary_matrix.pxi

@@ +1 @@
+r"""
+A binary matrix datatype in Cython
+
+It's almost a copy of the bitset datatype, but allows a differentiation of the
+rows of the matrix. That's the only advantage compared to storing all the rows
+of a matrix in a loooooonng bitset.
+
+a ``binary_matrix_t`` structure contains :
+
+- ``long n_cols`` -- number of columns
+
+- ``long n_rows`` -- number of rows
+
+- ``long width`` -- number of ``unsigned long`` per row
+
+- ``unsigned long ** rows`` -- ``rows[i]`` points toward the ``width`` blocks of
+  type ``unsigned long`` containing the bits of row `i`.
+
+.. NOTE::
+
+    The rows are stored contiguously in memory, i.e. ``row[i] = row[i-1] +
+    width``.
+"""
+include "binary_matrix_pxd.pxi"
+
+cdef inline binary_matrix_init(binary_matrix_t m, long n_rows, long n_cols):
+    r"""
+    Allocates the binary matrix.
+    """
+    cdef int i
+
+    m.n_cols = n_cols
+    m.n_rows = n_rows
+    m.width = (n_cols - 1)/(8*sizeof(unsigned long)) + 1
+    m.rows = <unsigned long**>sage_malloc(n_rows * sizeof(unsigned long *))
+    if m.rows == NULL:
+        raise MemoryError
+
+    m.rows[0] = <unsigned long*>sage_malloc(n_rows * m.width * sizeof(unsigned long))
+    if m.rows[0] == NULL:
+        sage_free(m.rows)
+        raise MemoryError
+
+    for i in range(1,n_rows):
+        m.rows[i] = m.rows[i-1] + m.width
+        m.rows[i][m.width-1] = 0
+
+cdef inline binary_matrix_free(binary_matrix_t m):
+    r"""
+    Frees the memory allocated by the matrix
+    """
+    sage_free(m.rows[0])
+    sage_free(m.rows)
+
+cdef inline binary_matrix_fill(binary_matrix_t m, bint bit):
+    r"""
+    Fill the whole matrix with a bit
+    """
+    memset(m.rows[0],-(<char> bit),m.width * m.n_rows * sizeof(unsigned long))
+
+cdef inline binary_matrix_set1(binary_matrix_t m, long row, long col):
+    r"""
+    Sets an entry to 1
+    """
+    m.rows[row][col >> index_shift] |= (<unsigned long>1) << (col & offset_mask)
+
+cdef inline binary_matrix_set0(binary_matrix_t m, long row, long col):
+    r"""
+    Sets an entry to 1
+    """
+    m.rows[row][col >> index_shift] &= ~((<unsigned long>1) << (col & offset_mask))
+
+cdef inline binary_matrix_set(binary_matrix_t m, long row, long col, bint value):
+    r"""
+    Sets an entry
+    """
+    binary_matrix_set0(m,row,col)
+    m.rows[row][col >> index_shift] |= (<unsigned long>1) << (value & offset_mask)
+
+cdef inline bint binary_matrix_get(binary_matrix_t m, long row, long col):
+    r"""
+    Returns the value of a given entry
+    """
+    return (m.rows[row][col >> index_shift] >> (col & offset_mask)) & 1
+
+cdef inline binary_matrix_print(binary_matrix_t m):
+    r"""
+    Prints the binary matrix
+    """
+    cdef int i,j
+    import sys
+    for i in range(m.n_rows):
+        for j in range(m.n_cols):
+            sys.stdout.write("1" if binary_matrix_get(m, i, j) else ".",)
+        print ""

new file sage/misc/binary_matrix_pxd.pxi

@@ +1 @@
+include "bitset_pxd.pxi"
+include "bitset.pxi"
+
+cdef extern from *:
+    int __builtin_popcountl(unsigned long)
+
+cdef struct binary_matrix_s:
+    long n_cols
+    long n_rows
+
+    # Number of "unsigned long" per row
+    long width
+
+    unsigned long ** rows
+
+ctypedef binary_matrix_s[1] binary_matrix_t
+