binomail_tree() supporting create_using ...

Also submitted as PR networkx/networkx#4461

This allows us to create trees with directed edges.

Author: rocky

pymathics/graph/__main__.py

@@ -100,7 +100,9 @@ def _process_graph_options(g, options: dict) -> None:
         else ""
     )
 
-    g.G.graph_layout = g.graph_layout = WL_LAYOUT_TO_NETWORKX.get(g.graph_layout, g.graph_layout)
+    g.G.graph_layout = g.graph_layout = WL_LAYOUT_TO_NETWORKX.get(
+        g.graph_layout, g.graph_layout
+    )
 
     g.G.node_color = g.node_color = WL_COLOR_TO_NETWORKX.get(color, color)
 
@@ -232,7 +234,7 @@ def _not_an_edge(self, expression, pos, evaluation):
 
     def _build_graph(self, graph, evaluation, options, expr, quiet=False):
         head = graph.get_head_name()
-        if head == "System`Graph" and isinstance(graph, Atom):
+        if head == "System`Graph" and isinstance(graph, Atom) and hasattr(graph, "G"):
             return graph
         elif head == "System`List":
             return _graph_from_list(graph.leaves, options)

pymathics/graph/algorithms.py

@@ -22,6 +22,47 @@
 # SymbolFalse = Symbol("System`False")
 # SymbolTrue = Symbol("System`True")
 
+class ConnectedComponents(_NetworkXBuiltin):
+    """
+    >> g = Graph[{1 -> 2, 2 -> 3, 3 <-> 4}]; ConnectedComponents[g]
+     = {{3, 4}, {2}, {1}}
+
+    >> g = Graph[{1 -> 2, 2 -> 3, 3 -> 1}]; ConnectedComponents[g]
+     = {{1, 2, 3}}
+
+    >> g = Graph[{1 <-> 2, 2 <-> 3, 3 -> 4, 4 <-> 5}]; ConnectedComponents[g]
+     = {{4, 5}, {1, 2, 3}}
+    """
+
+    def apply(self, graph, expression, evaluation, options):
+        "ConnectedComponents[graph_, OptionsPattern[%(name)s]]"
+        graph = self._build_graph(graph, evaluation, options, expression)
+        if graph:
+            connect_fn = nx.strongly_connected_components if graph.G.is_directed() else nx.connected_components
+            components = [
+                Expression("List", *c) for c in connect_fn(graph.G)
+            ]
+            return Expression("List", *components)
+
+
+# class FindHamiltonianPath(_NetworkXBuiltin):
+#     """
+#     <dl>
+#       <dt>'FindHamiltonianPath[$g$]'
+#       <dd>returns a Hamiltonian path in the given tournament graph.
+#       </dl>
+#     """
+#     def apply_(self, graph, expression, evaluation, options):
+#         "%(name)s[graph_, OptionsPattern[%(name)s]]"
+
+#         graph = self._build_graph(graph, evaluation, options, expression)
+#         if graph:
+#             # FIXME: for this to work we need to fill in all O(n^2) edges as an adjacency matrix?
+#             path = nx.algorithms.tournament.hamiltonian_path(graph.G)
+#             if path:
+#                 # int_path = map(Integer, path)
+#                 return Expression("List", *path)
+
 class GraphDistance(_NetworkXBuiltin):
     """
     <dl>
@@ -141,29 +182,6 @@ def apply(self, graph, expression, evaluation, options):
         is_planar, _ = nx.check_planarity(graph.G)
         return Symbol("System`True") if is_planar else Symbol("System`False")
 
-class ConnectedComponents(_NetworkXBuiltin):
-    """
-    >> g = Graph[{1 -> 2, 2 -> 3, 3 <-> 4}]; ConnectedComponents[g]
-     = {{3, 4}, {2}, {1}}
-
-    >> g = Graph[{1 -> 2, 2 -> 3, 3 -> 1}]; ConnectedComponents[g]
-     = {{1, 2, 3}}
-
-    >> g = Graph[{1 <-> 2, 2 <-> 3, 3 -> 4, 4 <-> 5}]; ConnectedComponents[g]
-     = {{4, 5}, {1, 2, 3}}
-    """
-
-    def apply(self, graph, expression, evaluation, options):
-        "ConnectedComponents[graph_, OptionsPattern[%(name)s]]"
-        graph = self._build_graph(graph, evaluation, options, expression)
-        if graph:
-            connect_fn = nx.strongly_connected_components if graph.G.is_directed() else nx.connected_components
-            components = [
-                Expression("List", *c) for c in connect_fn(graph.G)
-            ]
-            return Expression("List", *components)
-
-
 class WeaklyConnectedComponents(_NetworkXBuiltin):
     """
     >> g = Graph[{1 -> 2, 2 -> 3, 3 <-> 4}]; WeaklyConnectedComponents[g]

pymathics/graph/generators.py

@@ -6,6 +6,7 @@
 """
 
 from mathics.builtin.randomnumbers import RandomEnv
+from mathics.core.expression import String
 
 from pymathics.graph.__main__ import (
     Graph,
@@ -141,6 +142,35 @@ def apply(self, m1, m2, expression, evaluation, options):
         return g
 
 
+# Oddly, networkX doesn't allow the directed case.
+def binomial_tree(n, create_using=None):
+    """Returns the Binomial Tree of order n.
+
+    The binomial tree of order 0 consists of a single vertex. A binomial tree of order k
+    is defined recursively by linking two binomial trees of order k-1: the root of one is
+    the leftmost child of the root of the other.
+
+    Parameters
+    ----------
+    n : int
+        Order of the binomial tree.
+
+    Returns
+    -------
+    G : NetworkX graph
+        A binomial tree of $2^n$ vertices and $2^n - 1$ edges.
+
+    """
+    G = nx.empty_graph(1, create_using=create_using)
+    N = 1
+    for i in range(n):
+        edges = [(u + N, v + N) for (u, v) in G.edges]
+        G.add_edges_from(edges)
+        G.add_edge(0, N)
+        N *= 2
+    return G
+
+
 class BinomialTree(_NetworkXBuiltin):
     """
     <dl>
@@ -175,7 +205,7 @@ def apply(self, n, expression, evaluation, options):
             return
 
         args = (py_n,)
-        g = graph_helper(nx.binomial_tree, options, False, "tree", 0, *args)
+        g = graph_helper(binomial_tree, options, True, "tree", 0, *args)
         if not g:
             return None
         g.G.n = n