Added SwapDigraphs and DigraphsRemoveAllEdges functions

Author: rm387

doc/oper.xml

@@ -733,6 +733,27 @@ 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"/>
@@ -2291,6 +2312,69 @@ gap> HomomorphicProduct(D1, D2);
 </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="SwapDigraphs">
+<ManSection>
+  <Oper Name="SwapDigraphs" Arg="D1, D2"/>
+  <Description>
+  If <A>D1</A> and <A>D2</A> are mutable digraphs,
+  then <C>SwapDigraphs</C> will swap the contents of
+  <A>D1</A> and <A>D2</A>.
+
+  <Example><![CDATA[
+gap> D1 := Digraph(IsMutableDigraph, [[4],[5],[1,2],[],[]]);
+<mutable digraph with 5 vertices, 4 edges>
+gap> D2 := Digraph(IsMutableDigraph, [[2, 3, 4], [1, 3, 4, 5], [1, 2], [5], [4]]);
+<mutable digraph with 5 vertices, 11 edges>
+gap> SwapDigraphs(D1, D2);
+gap> OutNeighbours(D2);
+[ [ 4 ], [ 5 ], [ 1, 2 ], [  ], [  ] ]
+gap> OutNeighbours(D1);
+[ [ 2, 3, 4 ], [ 1, 3, 4, 5 ], [ 1, 2 ], [ 5 ], [ 4 ] ]
+]]></Example>
+</Description>
+</ManSection>
+<#/GAPDoc> 
+
 <#GAPDoc Label="LexicographicProduct">
 <ManSection>
   <Oper Name="LexicographicProduct" Arg="D1, D2"/>

gap/oper.gd

@@ -29,6 +29,8 @@ 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]);
@@ -59,6 +61,8 @@ DeclareSynonym("DigraphLexicographicProduct", LexicographicProduct);
 DeclareGlobalFunction("DIGRAPHS_CombinationOperProcessArgs");
 DeclareOperation("DIGRAPHS_GraphProduct", [IsDigraph, IsDigraph, IsFunction]);
 
+DeclareOperation("SwapDigraphs", [IsDigraph, IsDigraph]);
+
 # 4. Actions . . .
 DeclareOperation("OnDigraphs", [IsDigraph, IsPerm]);
 DeclareOperation("OnDigraphs", [IsDigraph, IsTransformation]);

gap/oper.gi

@@ -277,6 +277,25 @@ 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, neighbour, 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],
@@ -989,6 +1008,48 @@ function(D1, D2, edge_function)
   return Digraph(edges);
 end);
 
+InstallMethod(SwapDigraphs, 
+"for a digraph and digraph", 
+[IsDigraph, IsDigraph], 
+function(D1, D2)
+  local nb1, nb2, i, neighbour, d2edges;
+
+  if IsMutableDigraph(D1) and IsMutableDigraph(D2) then
+    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;
+end);
+
 ###############################################################################
 # 4. Actions
 ###############################################################################

tst/standard/oper.tst

@@ -109,6 +109,22 @@ 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>
@@ -2523,6 +2539,40 @@ gap> OutNeighbours(last);
 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);
+gap> OutNeighbours(D1);
+[ [ 4 ], [ 5 ], [ 1, 2 ], [  ], [  ] ]
+gap> OutNeighbours(D2);
+[ [ 2, 3, 4 ], [ 1, 3, 4, 5 ], [ 1, 2 ], [ 5 ], [ 4 ] ]
+gap> D3 := Digraph(IsMutableDigraph, [[2],[1],[2]]);
+<mutable digraph with 3 vertices, 3 edges>
+gap> SwapDigraphs(D1, D3);
+gap> OutNeighbours(D1);
+[ [ 2 ], [ 1 ], [ 2 ] ]
+gap> OutNeighbours(D3);
+[ [ 4 ], [ 5 ], [ 1, 2 ], [  ], [  ] ]
+gap> SwapDigraphs(D1, D3);
+gap> OutNeighbours(D1);
+[ [ 4 ], [ 5 ], [ 1, 2 ], [  ], [  ] ]
+gap> OutNeighbours(D3);
+[ [ 2 ], [ 1 ], [ 2 ] ]
+gap> D2 := Digraph(IsMutableDigraph, [[],[],[]]);
+<mutable empty digraph with 3 vertices>
+gap> SwapDigraphs(D3, D2);
+gap> OutNeighbours(D2);
+[ [ 2 ], [ 1 ], [ 2 ] ]
+gap> OutNeighbours(D3);
+[ [  ], [  ], [  ] ]
+
 # DigraphShortestPathSpanningTree
 gap> D := Digraph([[2, 3, 4], [1, 3, 4, 5], [1, 2], [5], [4]]);
 <immutable digraph with 5 vertices, 11 edges>

tst/testinstall.tst

@@ -258,6 +258,11 @@ gap> DigraphNrEdges(gr2);
 gap> DigraphNrAdjacencies(gr2);
 21
 
+# DigraphRemoveAllEdges
+gap> gr := Digraph(IsMutableDigraph, [[3], [4], [5], [1, 5], [1, 2]]);;
+gap> DigraphRemoveAllEdges(gr);
+<mutable empty digraph with 5 vertices>
+
 #  Fix seg fault cause by wrong handling of no edges in
 # FuncDIGRAPH_SOURCE_RANGE
 gap> gr := Digraph([[]]);
@@ -536,6 +541,15 @@ gap> AutomorphismGroup(D)
 > = Group([(1, 2, 3), (1, 2), (4, 5, 6), (4, 5), (1, 4)(2, 5)(3, 6)]);
 true
 
+# SwapDigraphs
+gap> C := Digraph(IsMutableDigraph, [[4],[5],[1,2],[],[]]);;
+gap> D := Digraph(IsMutableDigraph, [[2, 3, 4], [1, 3, 4, 5], [1, 2], [5], [4]]);;
+gap> SwapDigraphs(C, D);
+gap> OutNeighbours(D);
+[ [ 4 ], [ 5 ], [ 1, 2 ], [  ], [  ] ]
+gap> OutNeighbours(C);
+[ [ 2, 3, 4 ], [ 1, 3, 4, 5 ], [ 1, 2 ], [ 5 ], [ 4 ] ]
+
 #
 gap> DIGRAPHS_StopTest();
 gap> STOP_TEST("Digraphs package: testinstall.tst", 0);