Merge branch 'master' into amalgamDigraphs

Author: james-d-mitchell

.VERSION

@@ -1 +1 @@
-1.5.2
+1.5.3

CHANGELOG.md

@@ -4,6 +4,15 @@ Wilf A. Wilson, Michael Young et al.
 
 Licensing information can be found in the `LICENSE` file.
 
+## Version 1.5.3 (released 20/05/2022)
+
+This is a minor release including the following changes:
+
+* digraph: fix String method for chains/cycles by @james-d-mitchell in https://github.com/digraphs/Digraphs/pull/542
+* Disable edge labels if not already set in some cases by @james-d-mitchell in https://github.com/digraphs/Digraphs/pull/540
+* build: remove the default flag -march=native by @james-d-mitchell in https://github.com/digraphs/Digraphs/pull/541
+* doc: fix typos by @james-d-mitchell in https://github.com/digraphs/Digraphs/pull/544
+
 ## Version 1.5.2 (released 30/03/2022)
 
 This is a very minor release containing technical changes for maintaining compatibility with other GAP packages.

PackageInfo.g

@@ -9,14 +9,14 @@
 ##
 
 ##  <#GAPDoc Label="PKGVERSIONDATA">
-##  <!ENTITY VERSION                  "1.5.2">
+##  <!ENTITY VERSION                  "1.5.3">
 ##  <!ENTITY GAPVERS                  "4.10.0">
 ##  <!ENTITY GRAPEVERS                "4.8.1">
 ##  <!ENTITY IOVERS                   "4.5.1">
 ##  <!ENTITY ORBVERS                  "4.8.2">
 ##  <!ENTITY DATASTRUCTURESVERS       "0.2.5">
 ##  <!ENTITY NAUTYTRACESINTERFACEVERS "0.2">
-##  <!ENTITY ARCHIVENAME    "digraphs-1.5.2">
+##  <!ENTITY ARCHIVENAME    "digraphs-1.5.3">
 ##  <!ENTITY COPYRIGHTYEARS "2014-22">
 ##  <#/GAPDoc>
 
@@ -28,8 +28,8 @@ _STANDREWSCS := Concatenation(["Jack Cole Building, North Haugh, ",
 SetPackageInfo(rec(
 PackageName := "Digraphs",
 Subtitle := "Graphs, digraphs, and multidigraphs in GAP",
-Version := "1.5.2",
-Date := "30/03/2022",  # dd/mm/yyyy format
+Version := "1.5.3",
+Date := "20/05/2022",  # dd/mm/yyyy format
 License := "GPL-3.0-or-later",
 ArchiveFormats := ".tar.gz",
 
@@ -219,7 +219,17 @@ rec(
     Place         := "St Andrews",
     Institution   := "University of St Andrews"),
 
-  rec(
+rec(
+    LastName      := "Sharma",
+    FirstNames    := "Kamran",
+    IsAuthor      := false,
+    IsMaintainer  := false,
+    Email         := "[email protected]",
+    PostalAddress := _STANDREWSCS,
+    Place         := "St Andrews",
+    Institution   := "University of St Andrews"),
+
+rec(
     LastName      := "Smith",
     FirstNames    := "Finn",
     IsAuthor      := false,

VERSIONS

@@ -8,6 +8,7 @@
 #############################################################################
 ##
 
+release 1.5.3 - 20/05/2022
 release 1.5.2 - 30/03/2022
 release 1.5.1 - 29/03/2022
 release 1.5.0 - 27/10/2021

configure.ac

@@ -118,7 +118,7 @@ fi
 
 AX_CHECK_BLISS()
 
-# Check whether to use -march=native -mpopcnt and __builtin_ctzl
+# Check whether to use -mpopcnt and __builtin_ctzl
 AC_ARG_WITH([intrinsics],
             [AS_HELP_STRING([--without-intrinsics], 
                             [do not use compiler intrinsics even if available])]
@@ -127,10 +127,6 @@ AC_ARG_WITH([intrinsics],
 AS_IF([test "x$with_intrinsics" == "xno" ],
       [AC_MSG_NOTICE([compiler intrinsics will not be used even if available])])
 
-AS_IF([test "x$with_intrinsics" != "xno"],
-      [AX_CHECK_COMPILE_FLAG(-march=native, AX_APPEND_FLAG(-march=native))
-      ])
-
 dnl compiler builtins
 AC_DEFUN([CHECK_COMPILER_BUILTIN],
 [AC_MSG_CHECKING([for $1])

doc/digraph.xml

@@ -765,23 +765,56 @@ gap> List(D, x -> Size(x));
   <Returns>A digraph.</Returns>
   <Description>
     &STANDARD_FILT_TEXT;
+      
+    The other implemented filters are as follows:
+      <Ref Filt='IsConnectedDigraph'/>, <Ref Filt='IsSymmetricDigraph'/>, <Ref Filt='IsAcyclicDigraph'/>, <Ref Filt='IsEulerianDigraph'/>, <Ref Filt='IsHamiltonianDigraph'/>.<P/>
+      
+    For <Ref Filt='IsConnectedDigraph'/>, a random tree is first created independent of the value of <A>p</A>,
+      guaranteeing connectivity (with <M><A>n</A>-1</M> edges), and then edges are added between the remaining pairs
+      of vertices with probability approximately <A>p</A>.<P/>
+      
+    For <Ref Filt='IsHamiltonianDigraph'/>, a random Hamiltonian cycle is first created independent of the
+      value of <A>p</A> (with <A>n</A> edges), and then edges are added between the remaining pairs of vertices 
+      with probability approximately <A>p</A>.<P/>
+      
+    For <Ref Filt='IsEulerianDigraph'/>, a random Eulerian cycle is created where <A>p</A> influences how 
+      long the cycle will be. The cycle grows by randomly considering edges that extend the cycle, and 
+      adding an edge with probability approximately <A>p</A>. The cycle stops when we get back to the start vertex 
+      and have no more edges left to consider from it that extend the cycle further (any possible edge from the 
+      start vertex has either been added to the cycle, or rejected, leaving no more edges to consider). Thus 
+      <M><A>p</A> = 1</M> does not necessarily guarantee a complete digraph. Instead, it guarantees that all edges 
+      considered up to the point where the cycle stops, are added.<P/>
+      
+    For <Ref Filt='IsAcyclicDigraph'/> and <Ref Filt='IsSymmetricDigraph'/>, edges are added between any 
+      pairs of vertices with probability approximately <A>p</A>.<P/>
 
     If <A>n</A> is a positive integer, then this function returns a random
     digraph with <A>n</A> vertices and without multiple edges. The result
-    may or may not have loops.<P/>
+    may or may not have loops. If using <Ref Filt='IsAcyclicDigraph'/>, the resulting graph 
+      will not have any loops by definition.<P/>
 
     If the optional second argument <A>p</A> is a float with value
     <M>0 \leq </M> <A> p </A> <M> \leq 1</M>, then an edge will exist between each
     pair of vertices with probability approximately <A>p</A>.
     If <A>p</A> is not specified, then a random probability will be assumed
-    (chosen with uniform probability).
+    (chosen with uniform probability).<P/>
     <Log><![CDATA[
 gap> RandomDigraph(1000);
 <immutable digraph with 1000 vertices, 364444 edges>
 gap> RandomDigraph(10000, 0.023);
 <immutable digraph with 10000 vertices, 2300438 edges>
 gap> RandomDigraph(IsMutableDigraph, 1000, 1 / 2);
 <mutable digraph with 1000 vertices, 499739 edges>
+gap> RandomDigraph(IsConnectedDigraph, 1000, 0.75);
+<immutable digraph with 1000 vertices, 750265 edges>
+gap> RandomDigraph(IsSymmetricDigraph, 1000);
+<immutable digraph with 1000 vertices, 329690 edges>
+gap> RandomDigraph(IsAcyclicDigraph, 1000, 0.25);
+<immutable digraph with 1000 vertices, 125070 edges>
+gap> RandomDigraph(IsHamiltonianDigraph, 1000, 0.5);
+<immutable digraph with 1000 vertices, 500327 edges>
+gap> RandomDigraph(IsEulerianDigraph, 1000, 0.5);
+<immutable digraph with 1000 vertices, 433869 edges>
 ]]></Log>
   </Description>
 </ManSection>

doc/grahom.xml

@@ -808,7 +808,7 @@ false
   <C>MaximalCommonSubdigraph</C> returns a maximal common subgraph <C>M</C> of
   <A>D1</A> and <A>D2</A> with the maximum number of vertices. So <C>M</C> is a
   digraph which embeds into both <A>D1</A> and <A>D2</A> and has the largest
-  number of vertices amoung such digraphs.
+  number of vertices among such digraphs.
 
   It returns a list <C>[M, t1, t2]</C> where <C>M</C> is the maximal common
   subdigraph and <C>t1, t2</C> are transformations embedding <C>M</C> into
@@ -839,7 +839,7 @@ gap> MaximalCommonSubdigraph(NullDigraph(0), CompleteDigraph(10));
   <C>MinimalCommonSuperdigraph</C> returns a minimal common superdigraph
   <C>M</C> of <A>D1</A> and <A>D2</A> with the minimum number of vertices.
   So <C>M</C> is a digraph into which both <A>D1</A> and <A>D2</A> embed and
-  has the smallest number of vertices amoung such digraphs.
+  has the smallest number of vertices among such digraphs.
 
   It returns a list <C>[M, t1, t2]</C> where <C>M</C> is the minimal common 
   superdigraph and <C>t1, t2</C> are transformations embedding <A>D1</A> and

gap/attr.gi

@@ -1787,30 +1787,24 @@ function(D)
   return D;
 end);
 
-InstallMethod(DigraphAddAllLoops, "for a digraph by out-neighbours",
-[IsDigraphByOutNeighboursRep],
+InstallMethod(DigraphAddAllLoops, "for a digraph", [IsDigraph],
 function(D)
-  local ismulti, C, list, v;
-  if HasIsReflexiveDigraph(D) and IsReflexiveDigraph(D) then
-    return D;
-  fi;
-  ismulti := IsMultiDigraph(D);
+  local C, v;
   C := DigraphMutableCopyIfImmutable(D);
-  list := C!.OutNeighbours;
-  Assert(1, IsMutable(list));
-  for v in DigraphVertices(C) do
-    if not v in list[v] then
-      Add(list[v], v);
-      if not ismulti then
-        SetDigraphEdgeLabel(C, v, v, 1);
+
+  if not (HasIsReflexiveDigraph(D) and IsReflexiveDigraph(D)) then
+    for v in DigraphVertices(C) do
+      if not IsDigraphEdge(D, v, v) then
+        DigraphAddEdge(C, v, v);
       fi;
-    fi;
-  od;
+    od;
+  fi;
+
   if IsImmutableDigraph(D) then
     MakeImmutable(C);
     SetDigraphAddAllLoopsAttr(D, C);
     SetIsReflexiveDigraph(C, true);
-    SetIsMultiDigraph(C, ismulti);
+    SetIsMultiDigraph(C, IsMultiDigraph(D));
     SetDigraphHasLoops(C, DigraphHasAVertex(C));
   fi;
   return C;