Reinstate EdegeDelete somewhat...

Use that in AcycleGraphQ test.

More pytests-like tests moved out of doctests

Author: rocky

pymathics/graph/__init__.py

@@ -41,6 +41,7 @@
     AdjacencyList,
     DirectedEdge,
     EdgeConnectivity,
+    EdgeDelete,
     EdgeIndex,
     EdgeList,
     EdgeRules,
@@ -136,6 +137,7 @@
     "DirectedGraphQ",
     "EdgeConnectivity",
     "EdgeCount",
+    "EdgeDelete",
     "EdgeIndex",
     "EdgeList",
     "EdgeRules",

pymathics/graph/base.py

@@ -8,11 +8,11 @@
 
 from collections import defaultdict
 from inspect import isgenerator
-from typing import Callable, Optional
+from typing import Callable, Optional, Union
 
 from mathics.builtin.base import AtomBuiltin, Builtin
 from mathics.core.atoms import Atom, Integer, Integer0, Integer1, Integer2, String
-from mathics.core.convert.expression import ListExpression, from_python
+from mathics.core.convert.expression import ListExpression, from_python, to_mathics_list
 from mathics.core.element import BaseElement
 from mathics.core.expression import Expression
 from mathics.core.symbols import Symbol, SymbolList, SymbolTrue
@@ -283,7 +283,14 @@ def _not_a_vertex(self, expression, pos, evaluation):
     def _not_an_edge(self, expression, pos, evaluation):
         evaluation.message(self.get_name(), "inv", "edge", pos, expression)
 
-    def _build_graph(self, graph, evaluation, options, expr, quiet=False):
+    def _build_graph(
+        self,
+        graph: Union["Graph", Expression],
+        evaluation,
+        options: dict,
+        expr,
+        quiet=False,
+    ) -> Optional["Graph"]:
         head = graph.get_head()
         if head is SymbolGraph and isinstance(graph, Atom) and hasattr(graph, "G"):
             return graph
@@ -384,9 +391,6 @@ def __init__(self, Gr, **kwargs):
         self.G = Gr
         self.mixed = kwargs.get("mixed", False)
 
-        # Number of nodes
-        self.n: Optional[int] = None
-
         # Here we define types that appear on some, but not all
         # graphs. So these are optional, which we given an initial
         # value of None
@@ -441,14 +445,13 @@ def coalesced_graph(self, evaluation):
 
         return new_graph, "WEIGHT"
 
-    def delete_edges(self, edges_to_delete):
+    def delete_edges(self, edges_to_delete) -> "Graph":
         G = self.G.copy()
         directed = G.is_directed()
 
-        edges_to_delete = list(_normalize_edges(edges_to_delete))
-        edges_to_delete = self.edges.filter(edges_to_delete)
+        normalized_edges_to_delete = list(_normalize_edges(edges_to_delete))
 
-        for edge in edges_to_delete:
+        for edge in normalized_edges_to_delete:
             if edge.has_form("DirectedEdge", 2):
                 if directed:
                     u, v = edge.elements
@@ -461,12 +464,7 @@ def delete_edges(self, edges_to_delete):
                 else:
                     G.remove_edge(u, v)
 
-        edges = self.edges.clone()
-        edges.delete(edges_to_delete)
-
-        return Graph(
-            self.vertices, edges, G, self.layout, self.options, self.highlights
-        )
+        return Graph(G)
 
     def delete_vertices(self, vertices_to_delete):
         G = self.G.copy()
@@ -817,8 +815,7 @@ class AdjacencyList(_NetworkXBuiltin):
     :Adjacency list:
     https://en.wikipedia.org/wiki/Adjacency_list</url> (<url>
     :NetworkX:
-    https://networkx.org/documentation/networkx-2.8.8/reference/readwrite/adjlist.html</url>,
-    <url>
+    https://networkx.org/documentation/networkx-2.8.8/reference/readwrite/adjlist.html</url>, <url>
     :WMA:
     https://reference.wolfram.com/language/ref/AdjacencyList.html</url>)
 
@@ -1418,8 +1415,8 @@ class VertexDelete(_NetworkXBuiltin):
 
     summary_text = "remove a vertex"
 
-    def eval(self, graph, what, expression, evaluation, options):
-        "%(name)s[graph_, what_, OptionsPattern[%(name)s]]"
+    def eval(self, graph, what, expression, evaluation, options) -> Optional[Graph]:
+        "VertexDelete[graph_, what_, OptionsPattern[VertexDelete]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             from mathics.builtin import pattern_objects
@@ -1533,41 +1530,46 @@ class UndirectedEdge(Builtin):
 #                 return mathics_graph.add_edges(*zip(*[_parse_item(what)]))
 
 
-# class EdgeDelete(_NetworkXBuiltin):
-#     """
-#     >> Length[EdgeList[EdgeDelete[{a -> b, b -> c, c -> d}, b -> c]]]
-#      = 2
+class EdgeDelete(_NetworkXBuiltin):
+    """
+    <url>
+    :WMA:
+    https://reference.wolfram.com/language/ref/EdgeDelete.html</url>
 
-#     >> Length[EdgeList[EdgeDelete[{a -> b, b -> c, c -> b, c -> d}, b <-> c]]]
-#      = 4
+    <dl>
+      <dt>'EdgeDelete'[$g$, $edge$]
+      <dd>remove the edge $edge$.
+    </dl>
 
-#     >> Length[EdgeList[EdgeDelete[{a -> b, b <-> c, c -> d}, b -> c]]]
-#      = 3
+    >> g = Graph[{1 -> 2, 2 -> 3, 3 -> 1}, VertexLabels->True]
+     = -Graph-
 
-#     >> Length[EdgeList[EdgeDelete[{a -> b, b <-> c, c -> d}, c -> b]]]
-#      = 3
+    >> EdgeList[EdgeDelete[g, 2 -> 3]]
+     = {{1, 2}, {3, 1}}
 
-#     >> Length[EdgeList[EdgeDelete[{a -> b, b <-> c, c -> d}, b <-> c]]]
-#      = 2
+    ## >> g = Graph[{4<->5,5<->7,7<->9,9<->5,2->4,4->6,6->2}, VertexLabels->True]
+    ##  = -Graph-
 
-#     >> EdgeDelete[{4<->5,5<->7,7<->9,9<->5,2->4,4->6,6->2}, _UndirectedEdge]
-#      = -Graph-
-#     """
+    ## >> EdgeDelete[g, _UndirectedEdge]
+    ##  = -Graph-
+    """
 
-#     def eval(self, graph, what, expression, evaluation, options):
-#         "%(name)s[graph_, what_, OptionsPattern[%(name)s]]"
-#         graph = self._build_graph(graph, evaluation, options, expression)
-#         if graph:
-#             from mathics.builtin import pattern_objects
-
-#             head_name = what.get_head_name()
-#             if head_name in pattern_objects:
-#                 cases = Expression(
-#                     SymbolCases, ListExpression(*graph.edges), what
-#                 ).evaluate(evaluation)
-#                 if cases.get_head_name() == "System`List":
-#                     return graph.delete_edges(cases.elements)
-#             elif head_name == "System`List":
-#                 return graph.delete_edges(what.elements)
-#             else:
-#                 return graph.delete_edges([what])
+    summary_text = "remove an edge"
+
+    def eval(self, graph, what, expression, evaluation, options) -> Optional[Graph]:
+        "EdgeDelete[graph_, what_, OptionsPattern[EdgeDelete]]"
+        graph = self._build_graph(graph, evaluation, options, expression)
+        if graph:
+            from mathics.builtin import pattern_objects
+
+            head_name = what.get_head_name()
+            if head_name in pattern_objects:
+                cases = Expression(
+                    SymbolCases, to_mathics_list(*graph.edges), what
+                ).evaluate(evaluation)
+                if cases.get_head_name() == "System`List":
+                    return graph.delete_edges(cases.elements)
+            elif head_name == "System`List":
+                return graph.delete_edges(what.elements)
+            else:
+                return graph.delete_edges([what])

pymathics/graph/eval/parametric.py

@@ -80,5 +80,4 @@ def eval_hkn_harary(
     if not g:
         return None
     g.k = py_k
-    g.n = py_n
     return g

pymathics/graph/parametric.py

@@ -306,7 +306,7 @@ class CycleGraph(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "CycleGraph[n_Integer, OptionsPattern[CycleGragh]]"
+        "CycleGraph[n_Integer, OptionsPattern[CycleGraph]]"
         n_int = n.value
         if n_int < 3:
             return eval_complete_graph(self, n, expression, evaluation, options)
@@ -447,7 +447,6 @@ def eval(
         )
         if not g:
             return None
-        g.n = py_n
         g.m = py_m
         return g
 
@@ -653,5 +652,5 @@ def eval(
         g = graph_helper(nx.star_graph, options, False, "spring", evaluation, 0, *args)
         if not g:
             return None
-        g.G.n = n
+        g.G.n = py_n
         return g

pymathics/graph/properties.py

@@ -19,12 +19,11 @@ class AcyclicGraphQ(_NetworkXBuiltin):
     """
     <url>
     :Acyclic graph:
-    https://en.wikipedia.org/wiki/Acyclic_graph</url> (<url>
+    https://en.wikipedia.org/wiki/Acyclic_graph</url> test (<url>
     :NetworkX:
     https://networkx.org/documentation/stable/reference/algorithms\
 /generated/networkx.algorithms.cycles.find_cycle.html
-    </url>,
-    <url>
+    </url>, <url>
     :WMA:
     https://reference.wolfram.com/language/ref/AcyclicGraphQ.html</url>)
 
@@ -34,33 +33,27 @@ class AcyclicGraphQ(_NetworkXBuiltin):
     </dl>
 
 
-    >> g = Graph[{1 -> 2, 2 -> 3}]; AcyclicGraphQ[g]
-     = True
-
-    >> g = Graph[{1 -> 2, 2 -> 3, 5 -> 2, 3 -> 4, 3 -> 5}]; AcyclicGraphQ[g]
-     = False
+    Create a directed graph with a cycle in it:
 
-    #> g = Graph[{1 -> 2, 2 -> 3, 5 -> 2, 3 -> 4, 5 -> 3}]; AcyclicGraphQ[g]
-     = True
+    >> g = Graph[{1 -> 2, 2 -> 3, 5 -> 2, 3 -> 4, 3 -> 5}, VertexLabels->True]
+     = -Graph-
 
-    #> g = Graph[{1 -> 2, 2 -> 3, 5 -> 2, 3 -> 4, 5 <-> 3}]; AcyclicGraphQ[g]
+    >> AcyclicGraphQ[g]
      = False
 
-    #> g = Graph[{1 <-> 2, 2 <-> 3, 5 <-> 2, 3 <-> 4, 5 <-> 3}]; AcyclicGraphQ[g]
-     = False
+    Remove a cycle edge:
 
-    #> g = Graph[{}]; AcyclicGraphQ[{}]
-     = False
+    >> g = EdgeDelete[g, 5 -> 2]; EdgeList[g]
+     = {{1, 2}, {2, 3}, {3, 4}, {3, 5}}
 
-    #> AcyclicGraphQ["abc"]
-     = False
-     : Expected a graph at position 1 in AcyclicGraphQ[abc].
+    >> AcyclicGraphQ[g]
+     = True
     """
 
     summary_text = "test if is an acyclic graph"
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "AcyclicGraphQ[graph_, OptionsPattern[AcyclicGraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=False)
         if not graph or graph.empty():
             return SymbolFalse

test/test_base.py

@@ -30,3 +30,23 @@ def setup_module(module):
 )
 def test_degree_centrality(str_expr, str_expected, msg):
     check_evaluation(str_expr, str_expected, failure_message=msg)
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "str_expected", "msg"),
+    [
+        (None, None, None),
+        (
+            "Length[EdgeList[EdgeDelete[{a -> b, b -> c, c -> d}, b -> c]]]",
+            "2",
+            None,
+        ),
+        # ("Length[EdgeList[EdgeDelete[{a -> b, b -> c, c -> b, c -> d}, b <-> c]]]", "4", None),
+        ("Length[EdgeList[EdgeDelete[{a -> b, b <-> c, c -> d}, b -> c]]]", "3", None),
+        ("Length[EdgeList[EdgeDelete[{a -> b, b <-> c, c -> d}, c -> b]]]", "3", None),
+        ("Length[EdgeList[EdgeDelete[{a -> b, b <-> c, c -> d}, b <-> c]]]", "2", None),
+        (None, None, None),
+    ],
+)
+def test_edge_delete(str_expr, str_expected, msg):
+    check_evaluation(str_expr, str_expected, failure_message=msg)

test/test_properties.py

@@ -0,0 +1,41 @@
+"""
+Unit tests for pymathics.graph.measures_and_metrics
+"""
+
+from test.helper import check_evaluation, evaluate_value
+
+
+def setup_module(module):
+    """Load pymathics.graph"""
+    assert evaluate_value('LoadModule["pymathics.graph"]') == "pymathics.graph"
+
+
+def test_AcyclicQ():
+    for str_expr, str_expected, mess in [
+        (
+            "AcyclicGraphQ[Graph[{1 -> 2, 2 -> 3, 5 -> 2, 3 -> 4, 5 -> 3}]]",
+            "True",
+            None,
+        ),
+        (
+            "AcyclicGraphQ[Graph[{1 -> 2, 2 -> 3, 5 -> 2, 3 -> 4, 5 <-> 3}]]",
+            "False",
+            None,
+        ),
+        (
+            "AcyclicGraphQ[Graph[{1 <-> 2, 2 <-> 3, 5 <-> 2, 3 <-> 4, 5 <-> 3}]]",
+            "False",
+            None,
+        ),
+        # (
+        #     "AcyclicGraphQ[Graph[{}]]",
+        #     "False",
+        #     None,
+        # ),
+        (
+            'AcyclicGraphQ["abc"]',
+            "False",
+            ["Expected a graph at position 1 in AcyclicGraphQ[abc]."],
+        ),
+    ]:
+        check_evaluation(str_expr, str_expected, expected_messages=mess)