Faster perm(::Vector{Int}) & application of permutations

Before:

    julia> make_test_data(n) = (symmetric_group(n), vcat([n],1:n-1));

    julia> testit(pi) = [ i^pi for i in 1:degree(pi) ];

    julia> G, L = make_test_data(1000); pi = G(L); @b testit(pi)
    8.222 μs (492 allocs: 15.703 KiB)

    julia> G, L = make_test_data(10000); pi = G(L); @b testit(pi)
    98.916 μs (9492 allocs: 244.328 KiB)

    julia> G, L = make_test_data(100000); pi = G(L); @b testit(pi)
    1.069 ms (99492 allocs: 2.299 MiB)

    julia> G, L = make_test_data(1000); @b $G($L)
    12.834 μs (4 allocs: 10.016 KiB)

    julia> G, L = make_test_data(10000); @b $G($L)
    124.500 μs (4 allocs: 97.906 KiB)

    julia> G, L = make_test_data(100000); @b $G($L)
    1.235 ms (4 allocs: 1.145 MiB)

After:

    julia> make_test_data(n) = (symmetric_group(n), vcat([n],1:n-1));

    julia> testit(pi) = [ i^pi for i in 1:degree(pi) ];

    julia> G, L = make_test_data(1000); pi = G(L); @b testit(pi)
    1.041 μs (3 allocs: 8.062 KiB)

    julia> G, L = make_test_data(10000); pi = G(L); @b testit(pi)
    9.833 μs (3 allocs: 96.062 KiB)

    julia> G, L = make_test_data(100000); pi = G(L); @b testit(pi)
    104.625 μs (3 allocs: 800.062 KiB)

    julia> G, L = make_test_data(1000); @b $G($L)
    1.905 μs (2 allocs: 2.000 KiB)

    julia> G, L = make_test_data(10000); @b $G($L)
    16.458 μs (2 allocs: 19.641 KiB)

    julia> G, L = make_test_data(100000); @b $G($L)
    159.458 μs (2 allocs: 390.766 KiB)

Author: fingolfin

src/Groups/perm.jl

@@ -323,24 +323,51 @@ true
 ```
 """
 function perm(g::PermGroup, L::AbstractVector{<:IntegerUnion})
-   x = GAPWrap.PermList(GapObj(L;recursive=true))
+   x = _make_gap_perm(degree(g), L)
    @req x !== GAP.Globals.fail "the list does not describe a permutation"
-   @req (length(L) <= degree(g) && x in GapObj(g)) "the element does not embed in the group"
+   @req x in GapObj(g) "the element does not embed in the group"
    return PermGroupElem(g, x)
 end
 
 perm(g::PermGroup, L::AbstractVector{<:ZZRingElem}) = perm(g, [Int(y) for y in L])
 
 function (g::PermGroup)(L::AbstractVector{<:IntegerUnion})
-   x = GAPWrap.PermList(GapObj(L;recursive=true))
-   @req (length(L) <= degree(g) && x in GapObj(g)) "the element does not embed in the group"
+   x = _make_gap_perm(degree(g), L)
+   @req x in GapObj(g) "the element does not embed in the group"
    return PermGroupElem(g, x)
 end
 
+function _make_gap_perm(deg::Int, L::Vector{<:IntegerUnion})
+  @req 0 <= deg "degree is $deg, must be non-negative"
+  @req deg < 2^32 "degree is $deg, must be less than 2^32"
+  @req length(L) <= deg "length(L) = $(length(L)) exceeds degree bound $deg"
+  if deg < 2^16
+    x = _make_gap_perm(UInt16, deg, L)
+  else
+    x = _make_gap_perm(UInt32, deg, L)
+  end
+  return x
+end
+
+function _make_gap_perm(::Type{T}, deg::Int, L::Vector{<:IntegerUnion}) where {T <: Union{UInt16, UInt32}}
+  if T === UInt16
+    perm = @ccall GAP.libgap.NEW_PERM2(deg::Cint)::GapObj
+  else
+    perm = @ccall GAP.libgap.NEW_PERM4(deg::Cint)::GapObj
+  end
+  addr = Ptr{T}(GAP.ADDR_OBJ(perm)+8) # skip 8 byte header
+
+  for i in 1:length(L)
+    unsafe_store!(addr, UInt64(L[i]) - 1, i)
+  end
+  for i in 1+length(L):deg
+    unsafe_store!(addr, i - 1, i)
+  end
+  return perm
+end
+
 (g::PermGroup)(L::AbstractVector{<:ZZRingElem}) = g([Int(y) for y in L])
 
-# cperm stands for "cycle permutation", but we can change name if we want
-# takes as input a list of vectors (not necessarily disjoint)
 @doc raw"""
     cperm(L::AbstractVector{<:T}...) where T <: IntegerUnion
     cperm(L::AbstractVector{<:AbstractVector{T}}) where T <: IntegerUnion
@@ -501,9 +528,24 @@ Base.Vector(x::PermGroupElem, n::Int = x.parent.deg) = Vector{Int}(x,n)
 #evaluation function
 (x::PermGroupElem)(n::IntegerUnion) = n^x
 
-^(n::T, x::PermGroupElem) where T <: IntegerUnion = T(GAP.Obj(n)^GapObj(x))
+function ^(n::T, g::PermGroupElem) where T <: IntegerUnion
+  return fits(Int, n) ? T(Int(n)^g) : n
+end
+
+function ^(n::Int, g::PermGroupElem)
+  @req n > 0 "permutations only act on positive integers"
+  large = (GAP.TNUM_OBJ(GapObj(g)) == GAP.T_PERM4)
+  deg = GAP.SIZE_OBJ(GapObj(g)) - 8 # subtract 9 byte header
+  deg >>= large ? 2 : 1
+  n > deg && return n
 
-^(n::Int, x::PermGroupElem) = (n^GapObj(x))::Int
+  addr = GAP.ADDR_OBJ(GapObj(g))+8 # skip 8 byte header
+  if large
+    return Int(unsafe_load(Ptr{UInt32}(addr), n))+1
+  else
+    return Int(unsafe_load(Ptr{UInt16}(addr), n))+1
+  end
+end
 
 
 @doc raw"""

test/Groups/gsets.jl

@@ -135,7 +135,7 @@
   @test unwrap(x) == omega
   @test unwrap(omega) == omega
   @test x^g == Omega(permuted(omega, g))  # action via `^` is defined for `x`
-  @test_throws ErrorException omega^g  # ... but not for the unwrapped object
+  @test_throws ArgumentError omega^g  # ... but not for the unwrapped object
   orb = orbit(x)
   @test length(orb) == 6
   @test isa(orb, GSet)