More conversions and fixes

Author: rocky

pymathics/graph/__main__.py

@@ -9,6 +9,7 @@
 
 # uses networkx
 
+from collections import defaultdict
 from inspect import isgenerator
 
 from mathics.builtin.base import AtomBuiltin, Builtin
@@ -463,6 +464,29 @@ def __str__(self):
     def atom_to_boxes(self, f, evaluation) -> _BoxedString:
         return _BoxedString("-Graph-")
 
+    def coalesced_graph(self, evaluation):
+        if not isinstance(self.G, (nx.MultiDiGraph, nx.MultiGraph)):
+            return self.G, "WEIGHT"
+
+        new_edges = defaultdict(lambda: 0)
+        for u, v, w in self.G.edges.data("System`EdgeWeight", default=None):
+            if w is not None:
+                w = w.evaluate(evaluation).to_mpmath()
+            else:
+                w = 1
+            new_edges[(u, v)] += w
+
+        if self.G.is_directed():
+            new_graph = nx.DiGraph()
+        else:
+            new_graph = nx.Graph()
+
+        new_graph.add_edges_from(
+            ((u, v, {"WEIGHT": w}) for (u, v), w in new_edges.items())
+        )
+
+        return new_graph, "WEIGHT"
+
     def default_format(self, evaluation, form):
         return "-Graph-"
 
@@ -514,6 +538,29 @@ def get_sort_key(self, pattern_sort=False) -> tuple:
             ]
             return hash(self)
 
+    def update_weights(self, evaluation):
+        weights = None
+        G = self.G
+
+        if self.is_multigraph():
+            for u, v, k, w in G.edges.data(
+                "System`EdgeWeight", default=None, keys=True
+            ):
+                data = G.get_edge_data(u, v, key=k)
+                w = data.get()
+                if w is not None:
+                    w = w.evaluate(evaluation).to_mpmath()
+                    G[u][v][k]["WEIGHT"] = w
+                    weights = "WEIGHT"
+        else:
+            for u, v, w in G.edges.data("System`EdgeWeight", default=None):
+                if w is not None:
+                    w = w.evaluate(evaluation).to_mpmath()
+                    G[u][v]["WEIGHT"] = w
+                    weights = "WEIGHT"
+
+        return weights
+
     @property
     def value(self):
         return self.G
@@ -1578,7 +1625,7 @@ def apply(self, graph, expression, evaluation, options):
                 graph.G, normalized=False, weight=weight
             )
             return ListExpression(
-                *[Real(centrality.get(v, 0.0)) for v in graph.vertices.expressions],
+                *[Real(centrality.get(v, 0.0)) for v in graph.vertices],
             )
 
 
@@ -1601,7 +1648,7 @@ def apply(self, graph, expression, evaluation, options):
                 G = G.reverse()
             centrality = nx.closeness_centrality(G, distance=weight, wf_improved=False)
             return ListExpression(
-                *[Real(centrality.get(v, 0.0)) for v in graph.vertices.expressions],
+                *[Real(centrality.get(v, 0.0)) for v in graph.vertices],
             )
 
 
@@ -1620,7 +1667,7 @@ class DegreeCentrality(_Centrality):
     def _from_dict(self, graph, centrality):
         s = len(graph.G) - 1  # undo networkx's normalization
         return ListExpression(
-            *[Integer(s * centrality.get(v, 0)) for v in graph.vertices.expressions],
+            *[Integer(s * centrality.get(v, 0)) for v in graph.vertices],
         )
 
     def apply(self, graph, expression, evaluation, options):
@@ -1647,7 +1694,7 @@ def _centrality(self, g, weight):
         raise NotImplementedError
 
     def _compute(self, graph, evaluation, reverse=False, normalized=True, **kwargs):
-        vertices = graph.vertices.expressions
+        vertices = graph.vertices
         G, weight = graph.coalesced_graph(evaluation)
         if reverse:
             G = G.reverse()
@@ -1758,7 +1805,7 @@ def apply_alpha_beta(self, graph, alpha, expression, evaluation, options):
             G, weight = graph.coalesced_graph(evaluation)
             centrality = nx.pagerank(G, alpha=py_alpha, weight=weight, tol=1.0e-7)
             return ListExpression(
-                *[Real(centrality.get(v, 0)) for v in graph.vertices.expressions],
+                *[Real(centrality.get(v, 0)) for v in graph.vertices],
             )
 
 
@@ -1781,7 +1828,7 @@ def apply(self, graph, expression, evaluation, options):
             def _crop(x):
                 return 0 if x < tol else x
 
-            vertices = graph.vertices.expressions
+            vertices = graph.vertices
             return ListExpression(
                 ListExpression(*[Real(_crop(a.get(v, 0))) for v in vertices]),
                 ListExpression(*[Real(_crop(h.get(v, 0))) for v in vertices]),
@@ -1903,7 +1950,7 @@ def apply(self, graph, what, expression, evaluation, options):
             head_name = what.get_head_name()
             if head_name in pattern_objects:
                 cases = Expression(
-                    SymbolCases, ListExpression(*graph.vertices.expressions), what
+                    SymbolCases, ListExpression(*graph.vertices), what
                 ).evaluate(evaluation)
                 if cases.get_head_name() == "System`List":
                     return graph.delete_vertices(cases.elements)
@@ -1959,7 +2006,7 @@ def apply(self, graph, what, expression, evaluation, options):
             head_name = what.get_head_name()
             if head_name in pattern_objects:
                 cases = Expression(
-                    SymbolCases, ListExpression(*graph.edges.expressions), what
+                    SymbolCases, ListExpression(*graph.edges), what
                 ).evaluate(evaluation)
                 if cases.get_head_name() == "System`List":
                     return graph.delete_edges(cases.elements)

pymathics/graph/algorithms.py

@@ -5,10 +5,12 @@
 networkx does all the heavy lifting.
 """
 
+from mathics.core.convert.expression import to_mathics_list
 from mathics.core.convert.python import from_python
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
 from mathics.core.symbols import SymbolFalse
+from mathics.core.systemsymbols import SymbolDirectedInfinity
 
 from pymathics.graph.__main__ import (
     DEFAULT_GRAPH_OPTIONS,
@@ -23,7 +25,7 @@
 class ConnectedComponents(_NetworkXBuiltin):
     """
     >> g = Graph[{1 -> 2, 2 -> 3, 3 <-> 4}]; ConnectedComponents[g]
-     = {{3, 4}, {2}, {1}}
+     = {{4, 3}, {2}, {1}}
 
     >> g = Graph[{1 -> 2, 2 -> 3, 3 -> 1}]; ConnectedComponents[g]
      = {{1, 2, 3}}
@@ -41,8 +43,8 @@ def apply(self, graph, expression, evaluation, options):
                 if graph.G.is_directed()
                 else nx.connected_components
             )
-            components = [Expression("List", *c) for c in connect_fn(graph.G)]
-            return Expression("List", *components)
+            components = [to_mathics_list(*c) for c in connect_fn(graph.G)]
+            return ListExpression(*components)
 
 
 # class FindHamiltonianPath(_NetworkXBuiltin):
@@ -61,7 +63,7 @@ def apply(self, graph, expression, evaluation, options):
 #             path = nx.algorithms.tournament.hamiltonian_path(graph.G)
 #             if path:
 #                 # int_path = map(Integer, path)
-#                 return Expression("List", *path)
+#                 return to_mathics_list(*path)
 
 
 class GraphDistance(_NetworkXBuiltin):
@@ -110,8 +112,8 @@ def apply_s(self, graph, s, expression, evaluation, options):
         if graph:
             weight = graph.update_weights(evaluation)
             d = nx.shortest_path_length(graph.G, source=s, weight=weight)
-            inf = Expression("DirectedInfinity", 1)
-            return Expression("List", *[d.get(v, inf) for v in graph.vertices])
+            inf = Expression(SymbolDirectedInfinity, 1)
+            return to_mathics_list(*[d.get(v, inf) for v in graph.vertices])
 
     def apply_s_t(self, graph, s, t, expression, evaluation, options):
         "%(name)s[graph_, s_, t_, OptionsPattern[%(name)s]]"
@@ -130,7 +132,7 @@ def apply_s_t(self, graph, s, t, expression, evaluation, options):
                     nx.shortest_path_length(graph.G, source=s, target=t, weight=weight)
                 )
             except nx.exception.NetworkXNoPath:
-                return Expression("DirectedInfinity", 1)
+                return Expression(SymbolDirectedInfinity, 1)
 
 
 class FindSpanningTree(_NetworkXBuiltin):