Ticket #5793: cliquer.patch

module_list.py

@@ -222 +222 @@
     Extension('sage.graphs.chrompoly',
               sources = ['sage/graphs/chrompoly.pyx']),
 
+    Extension('sage.graphs.cliquer',
+              sources = ['sage/graphs/cliquer.pyx'],
+              libraries = ['cliquer']),
+
     Extension('sage.graphs.graph_fast',
               sources = ['sage/graphs/graph_fast.pyx'],
               libraries = ['gmp']),

new file sage/ext/cliquer.pxi

@@ +1 @@
+cdef extern from "cliquer/graph.h":
+    struct graph_t:
+       pass
+
+cdef extern from "cliquer/cliquer.h":
+    struct clique_options:
+       pass
+
+
+cdef extern from "cliquer/reorder.h":
+     cdef int *reorder_by_greedy_coloring(graph_t *g, bool weighted)
+     cdef int *reorder_by_degree(graph_t *g, bool weighted)
+
+cdef extern from "cliquer/cliquer.h":
+     bool clique_print_time(intlevel, int i, int n, int max, double cputime, double realtime, clique_options *opts)
+
+
+cdef extern from "cliquer/cl.h":
+     cdef int sage_clique_max(graph_t *g, int ** list)
+     cdef int sage_all_clique_max(graph_t *g, int ** list)
+     cdef int sage_clique_number(graph_t *g)
+     cdef void parse_input(char *str,graph_t *g)
+
+cdef extern from "cliquer/graph.h":
+     cdef graph_t * graph_new(int n)
+

sage/graphs/all.py

@@ -6 +6 @@
 import graph_list as graphs_list
 import sage.graphs.graph_fast
 import graph_coloring
-from graph_database import graph_db_info
- No newline at end of file
+from sage.graphs.cliquer import *
+from graph_database import graph_db_info

new file sage/graphs/cliquer.pyx

@@ +1 @@
+include '../ext/cliquer.pxi'
+
+# computes the maximum clique of a graph and return the list of its members
+
+def max_clique(graph):
+    cdef graph_t *g
+    g=graph_new(graph.order())
+    buf="p edges %d %d" %(graph.order(),graph.size())
+    parse_input(buf,g)
+
+    for e in graph.edge_iterator():
+          (u,v,w)=e
+          buf=' e %d %d' %(u,v)
+          parse_input(buf,g)
+
+
+    cdef int* list
+    cdef int size
+    size=sage_clique_max(g, &list)
+    b = []
+    cdef int i
+    for i in range(size):
+        b.append(list[i])
+    return b
+
+
+# computes all the maximum clique of a graph and return its list
+
+def all_max_clique(graph):
+    cdef graph_t *g
+    g=graph_new(graph.order())
+    buf="p edges %d %d" %(graph.order(),graph.size())
+    parse_input(buf,g)
+
+    for e in graph.edge_iterator():
+          (u,v,w)=e
+          buf=' e %d %d' %(u,v)
+          parse_input(buf,g)
+
+    cdef int* list
+    cdef int size
+    size=sage_all_clique_max(g, &list)
+    b = []
+    c=[]
+    cdef int i
+    for i in range(size):
+        if(list[i]!=-1):
+                c.append(list[i])
+        else:
+                b.append(c)
+                c=[]
+    return b
+
+
+#computes the clique number of a graph 
+
+def clique_number(graph):
+    cdef graph_t *g
+    g=graph_new(graph.order())
+    buf="p edges %d %d" %(graph.order(),graph.size())
+    parse_input(buf,g)
+
+    for e in graph.edge_iterator():
+          (u,v,w)=e
+          buf=' e %d %d' %(u,v)
+          parse_input(buf,g)
+    return sage_clique_number(g)

sage/graphs/graph.py

@@ -9238 +9238 @@
         from bipartite_graph import BipartiteGraph
         return BipartiteGraph(networkx.cliques.make_clique_bipartite(self.networkx_graph(copy=False), **kwds))
 
-    def clique_number(self, cliques=None):
+    def clique_number(self,algorithm="cliquer"):
         """
         Returns the size of the largest clique of the graph (clique
-        number).
+        number). By default, the Cliquer algorithm is used 
+        ( algorithm="Cliquer" ) but you can also chose the networkx
+        algorithm instead ( algorithm="networkx" )
         
         Currently only implemented for undirected graphs. Use
         to_undirected to convert a digraph to an undirected graph.
         
-        INPUT:
-        
-        
-        -  ``cliques`` - list of cliques (if already
-           computed)
-        
-        
         EXAMPLES::
         
             sage: C = Graph('DJ{')
             sage: C.clique_number()
             4
-            sage: E = C.cliques()
-            sage: E
-            [[4, 1, 2, 3], [4, 0]]
-            sage: C.clique_number(cliques=E)
-            4
             sage: G = Graph({0:[1,2,3], 1:[2], 3:[0,1]})
             sage: G.show(figsize=[2,2])
             sage: G.clique_number()
             3
         """
-        import networkx.cliques
-        return networkx.cliques.graph_clique_number(self.networkx_graph(copy=False), cliques)
-        
+        if algorithm=="networkx":
+            import networkx.cliques
+            return networkx.cliques.graph_clique_number(self.networkx_graph(copy=False), cliques)
+        
+        from sage.graphs.cliquer import clique_number
+        return clique_number(self)
+
+    def maximum_clique(self):
+        """
+        Returns the vertex set of a maximum complete subgraph.
+        
+        Currently only implemented for undirected graphs. Use
+        to_undirected to convert a digraph to an undirected graph.
+        
+        EXAMPLES::
+        
+        sage: C=graphs.PetersenGraph()
+        sage: C.maximum_cliq()
+        C.maximum_clique   C.maximum_cliques  
+        sage: C.maximum_clique()
+        [7, 9]
+        """
+        from sage.graphs.cliquer import max_clique
+        return max_clique(self)
+
+    def maximum_independent_set(self):
+        """
+        Returns the vertex set of a independent (stable) subgraph.
+        
+        Currently only implemented for undirected graphs. Use
+        to_undirected to convert a digraph to an undirected graph.
+        
+        EXAMPLES::
+        
+        sage: C=graphs.PetersenGraph()
+        sage: C.maximum_independent_set()
+        [0, 3, 6, 7]
+
+        """
+        from sage.graphs.cliquer import max_clique
+        return max_clique(self.complement())
+
+    def maximum_cliques(self):
+        """
+        Returns the vertex set of *ALL* the maximum complete subgraphs.
+        
+        Currently only implemented for undirected graphs. Use
+        to_undirected to convert a digraph to an undirected graph.
+        
+        EXAMPLES::
+        
+        sage: C=graphs.PetersenGraph()
+        sage: C.maximum_cliques()
+        
+        [[2, 7],
+        [7, 9],
+        [6, 8],
+        [6, 9],
+        [0, 4],
+        [4, 9],
+        [5, 7],
+        [0, 5],
+        [5, 8],
+        [3, 4],
+        [2, 3],
+        [3, 8],
+        [1, 6],
+        [0, 1],
+        [1, 2]]
+        """
+
+        from sage.graphs.cliquer import all_max_clique
+        return all_max_clique(self)
+
     def cliques_vertex_clique_number(self, vertices=None, with_labels=False, cliques=None):
         r"""
         Returns a list of sizes of the largest maximal cliques containing