Macro for entering permutations in cycle notation

src/Groups/perm.jl

@@ -387,3 +387,168 @@ function cycle_structure(g::PermGroupElem)
     # TODO: use SortedDict from DataStructures.jl ?
     return Pair{Int,Int}[ i+1 => c[i] for i in 1:length(c) if GAP.Globals.ISB_LIST(c, i) ]
 end
+
+
+# The following code implements a new way to input permutations in Julia. For example
+# it is possible to create a permutation as follow
+# pi = Oscar.Permutations.@perm (1,2,3)(4,5)(6,7,8)
+# > (1,2,3)(4,5)(6,7,8)
+# For this we use macros to modify the syntax tree of (1,2,3)(4,5)(6,7,8) such that
+# Julia can deal with the expression.
+
+
+################################################################################
+#
+#   perm
+#
+@doc Markdown.doc"""
+    @perm(ex)
+Macro to input a permutation as
+`pi = @perm (1,2,3)(4,5)(6,7,8)` to obtain
+the permutation `(1,2,3)(4,5)(6,7,8)`, that is, the output of
+`cperm([1,2,3],[4,5],[6,7,8])`.
+# Examples
+```jldoctest
+julia> @perm (1,2,3)(4,5)(6,7,8)
+(1,2,3)(4,5)(6,7,8)
+```
+"""
+macro perm(ex)
+    res = []
+
+    if typeof(ex) != Expr
+        error("Input is not a permutation.")
+    end
+
+    if ex.head != :call && ex.head != :tuple
+        error("Input is not a permutation.")
+    end
+
+    while ex.head == :call
+        pushfirst!(res, Expr(:vect, ex.args[2:end]...))
+        ex = ex.args[1]
+        if typeof(ex) != Expr
+            error("Input is not a permutation.")
+        end
+        if ex.head != :call && ex.head != :tuple
+            error("Input is not a permutation.")
+        end
+    end
+
+    if ex.head != :tuple
+        error("Input is not a permutation.")
+    end
+
+    pushfirst!(res, Expr(:vect,ex.args...))
+
+    return esc(:(Oscar.cperm($(res...))))
+end
+
+
+################################################################################
+#
+#   perm(n,gens)
+#
+@doc Markdown.doc"""
+    @perm(n,gens)
+Macro to input a list of permutations which are generated as elements of
+the `symmetric_group(n)` with the function `cperm`.
+# Examples
+```jldoctest
+julia> gens = Oscar.Permutations.@perm 14 [
+               (1,10)
+              (2,11)
+              (3,12)
+              (4,13)
+              (5,14)
+              (6,8)
+              (7,9)
+              (1,2,3,4,5,6,7)(8,9,10,11,12,13,14)
+              (1,2)(10,11)
+             ]
+9-element Vector{PermGroupElem}:
+ (1,10)
+ (2,11)
+ (3,12)
+ (4,13)
+ (5,14)
+ (6,8)
+ (7,9)
+ (1,2,3,4,5,6,7)(8,9,10,11,12,13,14)
+ (1,2)(10,11)
+julia> gens[1].parent
+Sym( [ 1 .. 14 ] )
+```
+"""
+macro perm(n,gens)
+
+    s = symmetric_group(n)
+    ores = Vector{Expr}(undef,length(gens.args))
+    i = 1
+    for ex in gens.args
+        res = []
+
+        if typeof(ex) != Expr
+            throw(ArgumentError("Input is not a permutation."))
+            error("Input is not a permutation.")
+        end
+
+        if ex.head != :call && ex.head != :tuple
+            error("Input is not a permutation.")
+        end
+
+        while ex.head == :call
+            pushfirst!(res, Expr(:vect, ex.args[2:end]...))
+            ex = ex.args[1]
+            if typeof(ex) != Expr
+                error("Input is not a permutation.")
+            end
+            if ex.head != :call && ex.head != :tuple
+                error("Input is not a permutation.")
+            end
+        end
+
+        if ex.head != :tuple
+            error("Input is not a permutation.")
+        end
+
+        pushfirst!(res, Expr(:vect,ex.args...))
+
+        ores[i] = esc(:(Oscar.cperm(symmetric_group($n),$(res...))))
+        i = i + 1
+    end
+
+    return Expr(:vect,ores...)
+end
+
+
+################################################################################
+#
+#   permgroup(n::Int64,gens::Vector{PermGroupElem})
+#
+@doc Markdown.doc"""
+    permgroup(n::Int64,gens::Vector{PermGroupElem})
+Generates a `PermGroup` with generators gens as a subgroup of `symmetric_group(n)`.
+# Examples
+```jldoctest
+julia> gens = Oscar.Permutations.@perm 14 [
+               (1,10)
+              (2,11)
+              (3,12)
+              (4,13)
+              (5,14)
+              (6,8)
+              (7,9)
+              (1,2,3,4,5,6,7)(8,9,10,11,12,13,14)
+              (1,2)(10,11)
+             ];
+julia> G = Oscar.Permutations.permgroup(14,gens)
+<permutation group with 9 generators>
+```
+"""
+function permgroup(n::Int64,gens::Vector{PermGroupElem})
+
+    return PermGroup(GAP.Globals.Subgroup(GAP.Globals.SymmetricGroup(GAP.Obj(n)),GAP.Obj([GAP.Obj(x) for x in gens ])))
+end
+
+export @perm,permgroup

test/Groups/Permutations.jl

@@ -0,0 +1,44 @@
+@testset "Examples.Permutations" begin
+  p = @perm (1,2)(3,4)(5,6)
+  @test p == cperm([1,2],[3,4],[5,6])
+  p = @perm (1,2)(3,4,5)(7,8,9)
+  @test p == cperm([1,2],[3,4,5],[7,8,9])
+
+  a=1;b=2;f=x->3*x + 2;
+  p = @perm (a,f(a),b)(a+1,b*2)
+  @test p == cperm([1,5,4,2])
+
+  @test_throws ErrorException @perm (-1, 1)
+  @test_throws LoadError @perm "bla"
+  @test_throws LoadError @perm 1 + 1
+
+  gens = @perm 14 [
+         (1,10)
+        (2,11)
+        (3,12)
+        (4,13)
+        (5,14)
+        (6,8)
+        (7,9)
+        (1,2,3,4,5,6,7)(8,9,10,11,12,13,14)
+        (1,2)(10,11)
+       ]
+  p = Vector{PermGroupElem}(undef,9)
+  p[1] = cperm(symmetric_group(14),[1,10])
+  p[2] = cperm(symmetric_group(14),[2,11])
+  p[3] = cperm(symmetric_group(14),[3,12])
+  p[4] = cperm(symmetric_group(14),[4,13])
+  p[5] = cperm(symmetric_group(14),[5,14])
+  p[6] = cperm(symmetric_group(14),[6,8])
+  p[7] = cperm(symmetric_group(14),[7,9])
+  p[8] = cperm(symmetric_group(14),[1,2,3,4,5,6,7],[8,9,10,11,12,13,14])
+  p[9] = cperm(symmetric_group(14),[1,2],[10,11])
+  @test gens == p
+
+  @test_throws ArgumentError @perm 10 [(1,11)]
+
+  G = permgroup(14,gens)
+  @test order(G) == 645120
+end
+
+

test/Groups/runtests.jl

@@ -21,3 +21,4 @@ include("MatrixDisplay.jl")
 include("group_characters.jl")
 include("FiniteFormOrthogonalGroup.jl")
 include("GrpAb.jl")
+include("Permutations.jl")