Implement CycleFromList, and fix potential crash in CYCLE_TRANS_INT

doc/ref/permutat.xml

@@ -125,6 +125,7 @@ false
 <#Include Label="PermList">
 <#Include Label="MappingPermListList">
 <#Include Label="RestrictedPerm">
+<#Include Label="CycleFromList">
 
 <ManSection>
   <Attr Name="AsPermutation" Arg="f"/>

lib/permutat.g

@@ -479,6 +479,64 @@ BIND_GLOBAL( "ListPerm", function( arg )
 end );
 
 
+#############################################################################
+##
+#F  CycleFromList( <list> )  . . . . . . . . . . . cycle defined from a list 
+##
+##  <#GAPDoc Label="CycleFromList">
+##  <ManSection>
+##  <Func Name="CycleFromList" Arg='list'/>
+##
+##  <Description>
+##  For the given dense, duplicate-free list of positive integers
+##  <M>[a_1, a_2, ..., a_n]</M>
+##  return the <M>n</M>-cycle <M>(a_1,a_2,...,a_n)</M>. For the empty list
+##  the trivial permutation <M>()</M> is returned.
+##  <P/>
+##  If the given <A>list</A> contains duplicates or holes, return <K>fail</K>.
+##  <P/>
+##  <Example><![CDATA[
+##  gap> CycleFromList( [1,2,3,4] );
+##  (1,2,3,4)
+##  gap> CycleFromList( [3,2,6,4,5] );
+##  (2,6,4,5,3)
+##  gap> CycleFromList( [2,3,2] );
+##  fail
+##  gap> CycleFromList( [1,,3] );
+##  fail
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+BIND_GLOBAL( "CycleFromList", function( list )
+    local max, images, set, i;
+
+    # Trivial case
+    if Length(list) = 0 then
+        return ();
+    fi;
+
+    if ForAny( list, i -> not IsPosInt(i) ) then
+        Error("CycleFromList: List must only contain positive integers.");
+    fi;
+
+    set := Set(list);
+    if Length(set) <> Length(list) then
+        # we found duplicates (or list was not dense)
+        return fail;
+    fi;
+    max := Maximum( set );
+    images := [1..max];
+    for i in [1..Length(list)-1] do
+        images[ list[i] ] := list[i+1];
+    od;
+    images[ list[Length(list)] ] := list[1];
+
+    return PermList(images);
+end );
+
+
 #############################################################################
 ##
 #O  RestrictedPerm(<perm>,<list>)  restriction of a perm. to an invariant set

src/trans.c

@@ -3102,6 +3102,7 @@ Obj FuncCYCLE_TRANS_INT(Obj self, Obj f, Obj pt)
         i = cpt;
         do {
             AssPlist(out, ++len, INTOBJ_INT(i + 1));
+            ptf2 = CONST_ADDR_TRANS2(f);
             i = ptf2[i];
         } while (i != cpt);
     }
@@ -3116,6 +3117,7 @@ Obj FuncCYCLE_TRANS_INT(Obj self, Obj f, Obj pt)
         i = cpt;
         do {
             AssPlist(out, ++len, INTOBJ_INT(i + 1));
+            ptf4 = CONST_ADDR_TRANS4(f);
             i = ptf4[i];
         } while (i != cpt);
     }

tst/testinstall/opers/CyclesFromList.tst

@@ -0,0 +1,32 @@
+gap> START_TEST("CyclesFromList");
+
+#
+gap> CycleFromList( [1..10] );
+(1,2,3,4,5,6,7,8,9,10)
+gap> CycleFromList( [1,5,4,8] );
+(1,5,4,8)
+gap> CycleFromList( [9,10,3,5]);
+(3,5,9,10)
+gap> CycleFromList( [1,3,,9] );
+fail
+gap> CycleFromList( [1,3,3,8] );
+fail
+
+# Errors
+gap> CycleFromList( [7,2,0,3] );
+Error, CycleFromList: List must only contain positive integers.
+gap> CycleFromList( [9,3,-7,8,9] );
+Error, CycleFromList: List must only contain positive integers.
+gap> CycleFromList( [2,2,1/2,6] );
+Error, CycleFromList: List must only contain positive integers.
+
+# 
+gap> CycleFromList( [] );
+()
+gap> CycleFromList( [7] );
+()
+gap> CycleFromList( [0] );
+Error, CycleFromList: List must only contain positive integers.
+gap> CycleFromList( [true] );
+Error, CycleFromList: List must only contain positive integers.
+gap> STOP_TEST("CyclesFromList", 1);