Changes made to SwapDigraphs and DigraphRemoveAllEdges

Author: rm387

doc/attr.xml

@@ -2091,6 +2091,30 @@ gap> D;
 </ManSection>
 <#/GAPDoc>
 
+<#GAPDoc Label="DigraphRemoveAllEdges">
+<ManSection>
+  <Oper Name="DigraphRemoveAllEdges" Arg="digraph"/>
+  <Attr Name="DigraphRemoveAllEdgesAttr" Arg="digraph"/>
+  <Returns>An empty digraph.</Returns>
+  <Description>
+    This operation returns a digraph constructed from <A>digraph</A>, which is mutable,
+    by removing all of the edges in the original digraph
+    (see <Ref Oper="DigraphRemoveEdge" Label="for a digraph and an edge"/>).
+    <P/>
+
+    If <A>digraph</A> is immutable, then a new, empty immutable digraph with the same number of vertices is returned.
+
+    <Example><![CDATA[
+gap> D3 := Digraph(IsMutableDigraph, [[2], [1], [2]]);
+<mutable digraph with 3 vertices, 3 edges>
+gap> DigraphRemoveAllEdges(D3);
+<mutable empty digraph with 3 vertices>
+true
+]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
 <#GAPDoc Label="DigraphAddAllLoops">
 <ManSection>
   <Oper Name="DigraphAddAllLoops" Arg="digraph"/>

doc/oper.xml

@@ -733,27 +733,6 @@ true
 </ManSection>
 <#/GAPDoc>
 
-<#GAPDoc Label="DigraphRemoveAllEdges">
-<ManSection>
-  <Oper Name="DigraphRemoveAllEdges" Arg="digraph"/>
-  <Returns>An empty digraph.</Returns>
-  <Description>
-    This operation returns a digraph constructed from <A>digraph</A>, which is mutable,
-    by removing all of the edges in the original digraph.
-    (see <Ref Oper="DigraphRemoveEdge" Label="for a digraph and an edge"/>).
-    <P/>
-
-    <Example><![CDATA[
-gap> D3 := Digraph(IsMutableDigraph, [[2], [1], [2]]);
-<mutable digraph with 3 vertices, 3 edges>
-gap> DigraphRemoveAllEdges(D3);
-<mutable empty digraph with 3 vertices>
-true
-]]></Example>
-  </Description>
-</ManSection>
-<#/GAPDoc>
-
 <#GAPDoc Label="InducedSubdigraph">
 <ManSection>
   <Oper Name="InducedSubdigraph" Arg="digraph, verts"/>
@@ -2273,46 +2252,6 @@ gap> ConormalProduct(NullDigraph(0), CompleteDigraph(10));
 </ManSection>
 <#/GAPDoc>
 
-<#GAPDoc Label="HomomorphicProduct">
-<ManSection>
-  <Oper Name="HomomorphicProduct" Arg="D1, D2"/>
-  <Returns>A digraph.</Returns>
-  <Description>
-  If <A>D1</A> and <A>D2</A> are digraphs without multiple edges,
-  then <C>HomomorphicProduct</C> calculates the <E>homomorphic product digraph</E>
-  (<C>HPD</C>) of <A>D1</A> and <A>D2</A>.
-
-  <C>HPD</C> has vertex set <C>V1 x V2</C> where <C>V1</C> is the vertex set of
-  <A>D1</A> and <C>V2</C> is the vertex set of <A>D2</A> (a vertex
-  <C>[a, b]</C> has label <C>(a - 1) * |V2| + b</C> in the  output). There is
-  an edge from <C>[a, b]</C> to <C>[c, d]</C> when at least one of the
-  following two conditions are satisfied:
-  <List>
-    <Item>
-      The vertices <C>a</C> and <C>c</C> of <A>D1</A> are equal.
-    </Item>
-    <Item>
-      There is an edge from <C>a</C> to <C>c</C> in <A>D1</A> and no edge from
-      <C>b</C> to <C>d</C> in <A>D2</A>.
-    </Item>
-  </List>
-
-  <Example><![CDATA[
-gap> HomomorphicProduct(PetersenGraph(),
-> DigraphSymmetricClosure(ChainDigraph(4)));
-<immutable digraph with 40 vertices, 460 edges>
-gap> D1 := Digraph([[2], [1, 3, 4], [2, 5], [2, 5], [3, 4]]);
-<immutable digraph with 5 vertices, 10 edges>
-gap> D2 := Digraph([[2], [1, 3], [2, 4], [3]]);
-<immutable digraph with 4 vertices, 6 edges>
-gap> HomomorphicProduct(D1, D2);
-<immutable digraph with 20 vertices, 180 edges>
-]]></Example>
-</Description>
-</ManSection>
-<#/GAPDoc>
-
-
 <#GAPDoc Label="HomomorphicProduct">
 <ManSection>
   <Oper Name="HomomorphicProduct" Arg="D1, D2"/>

gap/attr.gd

@@ -89,6 +89,7 @@ DeclareAttributeThatReturnsDigraph("DigraphReverse", IsDigraph);
 DeclareAttributeThatReturnsDigraph("DigraphDual", IsDigraph);
 DeclareAttributeThatReturnsDigraph("ReducedDigraph", IsDigraph);
 DeclareAttributeThatReturnsDigraph("DigraphRemoveAllMultipleEdges", IsDigraph);
+DeclareAttributeThatReturnsDigraph("DigraphRemoveAllEdges", IsDigraph);
 
 # TODO replace all DeclareOperations below to
 # DeclareAttributeThatReturnsDigraph, and remove the *Attr versions.

gap/attr.gi

@@ -2537,6 +2537,26 @@ function(D)
   return D;
 end);
 
+InstallMethodThatReturnsDigraph(DigraphRemoveAllEdges, "for a digraph",
+[IsDigraph],
+function(D)
+  local i, nbs, currentEdges, emptynbs;
+  nbs := OutNeighboursMutableCopy(D);
+  if IsImmutableDigraph(D) then
+    emptynbs := [];
+    for i in [1 .. Length(nbs)] do
+      Add(emptynbs, []);
+    od;
+    return Digraph(IsImmutableDigraph, emptynbs);
+  else
+    for i in [1 .. Length(nbs)] do
+      currentEdges := DigraphOutEdges(D, i);
+      DigraphRemoveEdges(D, currentEdges);
+    od;
+    return D;
+  fi;
+end);
+
 InstallMethod(DigraphAddAllLoops, "for a digraph", [IsDigraph],
 function(D)
   local C, v;

gap/oper.gd

@@ -29,8 +29,6 @@ DeclareOperation("DigraphRemoveEdge", [IsDigraph, IsPosInt, IsPosInt]);
 DeclareOperation("DigraphRemoveEdge", [IsDigraph, IsList]);
 DeclareOperation("DigraphRemoveEdges", [IsDigraph, IsList]);
 
-DeclareOperation("DigraphRemoveAllEdges", [IsDigraph]);
-
 DeclareOperation("DigraphReverseEdge", [IsDigraph, IsList]);
 DeclareOperation("DigraphReverseEdge", [IsDigraph, IsPosInt, IsPosInt]);
 DeclareOperation("DigraphReverseEdges", [IsDigraph, IsList]);

gap/oper.gi

@@ -277,23 +277,6 @@ InstallMethod(DigraphRemoveEdges, "for an immutable digraph and a list",
 [IsImmutableDigraph, IsList],
 {D, edges} -> MakeImmutable(DigraphRemoveEdges(DigraphMutableCopy(D), edges)));
 
-InstallMethod(DigraphRemoveAllEdges, "for a mutable digraph",
-[IsDigraph],
-function(D)
-  local i, nbs, currentEdges;
-  if IsImmutableDigraph(D) then
-    ErrorNoReturn("Argument must be a mutable digraph");
-  else
-    nbs := OutNeighboursMutableCopy(D);
-    for i in [1 .. Length(nbs)] do
-      currentEdges := DigraphOutEdges(D, i);
-      DigraphRemoveEdges(D, currentEdges);
-    od;
-
-    return D;
-  fi;
-end);
-
 InstallMethod(DigraphReverseEdge,
 "for a mutable digraph by out-neighbours and two positive integers",
 [IsMutableDigraph and IsDigraphByOutNeighboursRep, IsPosInt, IsPosInt],
@@ -1008,43 +991,13 @@ end);
 
 InstallMethod(SwapDigraphs,
 "for a digraph and digraph",
-[IsDigraph, IsDigraph],
+[IsMutableDigraph, IsMutableDigraph],
 function(D1, D2)
-  local nb1, nb2, i;
-
-  if IsMutableDigraph(D1) and IsMutableDigraph(D2) then
+  local nb1, nb2;
     nb1 := OutNeighboursMutableCopy(D1);
     nb2 := OutNeighboursMutableCopy(D2);
-    DigraphRemoveAllEdges(D1);
-    DigraphRemoveAllEdges(D2);
-
-        # If the second digraph has more vertices than the first
-    if Length(nb2) < Length(nb1) then
-      for i in [Length(nb2) .. Length(nb1) - 1] do
-        DigraphRemoveVertex(D1, Length(nb2) + 1);
-        DigraphAddVertex(D2);
-      od;
-    else
-      for i in [Length(nb1) .. Length(nb2) - 1] do
-        DigraphRemoveVertex(D2, Length(nb1) + 1);
-        DigraphAddVertex(D1);
-      od;
-    fi;
-
-    for i in [1 .. Length(nb2)] do
-      for neighbour in nb2[i] do
-        DigraphAddEdge(D1, i, neighbour);
-      od;
-    od;
-
-    for i in [1 .. Length(nb1)] do
-      for neighbour in nb1[i] do
-        DigraphAddEdge(D2, i, neighbour);
-      od;
-    od;
-  else
-    ErrorNoReturn("Arguments must be mutable digraphs");
-  fi;
+    D1!.OutNeighbours := nb2;
+    D2!.OutNeighbours := nb1;
 end);
 
 ###############################################################################

tst/standard/attr.tst

@@ -2548,6 +2548,22 @@ true
 gap> IsChainDigraph(MaximalAntiSymmetricSubdigraph(D));
 true
 
+# DigraphRemoveAllEdges: for a digraph
+gap> gr := Digraph(IsImmutableDigraph, [[2, 3], [3], [4], []]);
+<immutable digraph with 4 vertices, 4 edges>
+gap> DigraphRemoveAllEdges(gr);
+<immutable empty digraph with 4 vertices>
+gap> gr2 := Digraph(IsMutableDigraph, [[2, 3], [3], [4], []]);
+<mutable digraph with 4 vertices, 4 edges>
+gap> DigraphRemoveAllEdges(gr2);
+<mutable empty digraph with 4 vertices>
+gap> gr3 := Digraph(IsMutableDigraph, [[], [], [], []]);
+<mutable empty digraph with 4 vertices>
+gap> DigraphRemoveAllEdges(gr3);
+<mutable empty digraph with 4 vertices>
+gap> OutNeighbours(gr3);
+[ [  ], [  ], [  ], [  ] ]
+
 # CharacteristicPolynomial
 gap> gr := Digraph([
 > [2, 2, 2], [1, 3, 6, 8, 9, 10], [4, 6, 8],

tst/standard/oper.tst

@@ -109,22 +109,6 @@ gap> gr := DigraphRemoveEdge(gr, [2, 1]);
 gap> DigraphEdges(gr);
 [ [ 1, 2 ] ]
 
-# DigraphRemoveAllEdges: for a digraph
-gap> gr := Digraph(IsImmutableDigraph, [[2, 3], [3], [4], []]);
-<immutable digraph with 4 vertices, 4 edges>
-gap> DigraphRemoveAllEdges(gr);
-Error, Argument must be a mutable digraph
-gap> gr2 := Digraph(IsMutableDigraph, [[2, 3], [3], [4], []]);
-<mutable digraph with 4 vertices, 4 edges>
-gap> DigraphRemoveAllEdges(gr2);
-<mutable empty digraph with 4 vertices>
-gap> gr3 := Digraph(IsMutableDigraph, [[], [], [], []]);
-<mutable empty digraph with 4 vertices>
-gap> DigraphRemoveAllEdges(gr3);
-<mutable empty digraph with 4 vertices>
-gap> OutNeighbours(gr3);
-[ [  ], [  ], [  ], [  ] ]
-
 #  OnDigraphs: for a digraph and a perm
 gap> gr := Digraph([[2], [1], [3]]);
 <immutable digraph with 3 vertices, 3 edges>
@@ -2540,12 +2524,8 @@ gap> LexicographicProduct(ChainDigraph(3), CycleDigraph(7));
 <immutable digraph with 21 vertices, 119 edges>
 
 # SwapDigraphs
-gap> D1 := Digraph([[2, 3, 4], [1, 3, 4, 5], [1, 2], [5], [4]]);
-<immutable digraph with 5 vertices, 11 edges>
 gap> D2 := Digraph(IsMutableDigraph, [[4], [5], [1, 2], [], []]);
 <mutable digraph with 5 vertices, 4 edges>
-gap> SwapDigraphs(D1, D2);
-Error, Arguments must be mutable digraphs
 gap> D1 := Digraph(IsMutableDigraph, [[2, 3, 4], [1, 3, 4, 5], [1, 2], [5], [4]]);
 <mutable digraph with 5 vertices, 11 edges>
 gap> SwapDigraphs(D1, D2);