kalmar/Groups.jl
1
0
Fork 0
mirror of https://github.com/kalmarek/Groups.jl.git synced 2024-11-19 06:30:29 +01:00
Code Issues Releases Wiki Activity

update to AbstractAlgebra v0.9

Browse Source
This commit is contained in:
kalmarek 2020-03-25 13:48:44 +01:00
parent 622f5bc6b3
commit 0bee697ed8
No known key found for this signature in database
GPG Key ID: 8BF1A3855328FC15
7 changed files with 26 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Project.toml
View File

@ -8,11 +8,11 @@ AbstractAlgebra = "c3fe647b-3220-5bb0-a1ea-a7954cac585d"
LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
[compat]
AbstractAlgebra = "^0.9.0"
[extras]
Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
[targets]
test = ["Test"]
[compat]
AbstractAlgebra = "^0.7.0"

2
src/AutGroup.jl
View File

@ -170,7 +170,7 @@ function AutGroup(G::FreeGroup; special=false)
if !special
flips = [flip(i) for i in 1:n]
syms = [AutSymbol(p) for p in PermutationGroup(Int8(n))][2:end]
syms = [AutSymbol(p) for p in SymmetricGroup(Int8(n))][2:end]
append!(S, [flips; syms])
end

15
src/WreathProducts.jl
View File

@ -1,5 +1,7 @@
export WreathProduct, WreathProductElem
import AbstractAlgebra: AbstractPermutationGroup, AbstractPerm
###############################################################################
#
# WreathProduct / WreathProductElem
@ -19,22 +21,23 @@ export WreathProduct, WreathProductElem
* `N::Group` : the single factor of the group $N$
* `P::Generic.PermGroup` : full `PermutationGroup`
"""
struct WreathProduct{N, T<:Group, PG<:Generic.PermGroup} <: Group
struct WreathProduct{N, T<:Group, PG<:AbstractPermutationGroup} <: Group
N::DirectPowerGroup{N, T}
P::PG
function WreathProduct(Gr::T, P::PG) where {T, PG<:Generic.PermGroup}
N = DirectPowerGroup(Gr, Int(P.n))
return new{Int(P.n), T, PG}(N, P)
function WreathProduct(G::Gr, P::PG) where
{Gr <: Group, PG <: AbstractPermutationGroup}
N = DirectPowerGroup(G, Int(P.n))
return new{Int(P.n), Gr, PG}(N, P)
end
end
struct WreathProductElem{N, T<:GroupElem, P<:Generic.Perm} <: GroupElem
struct WreathProductElem{N, T<:GroupElem, P<:AbstractPerm} <: GroupElem
n::DirectPowerGroupElem{N, T}
p::P
function WreathProductElem(n::DirectPowerGroupElem{N,T}, p::P,
check::Bool=true) where {N, T, P<:Generic.Perm}
check::Bool=true) where {N, T, P<:AbstractPerm}
if check
N == length(p.d) || throw(DomainError(
"Can't form WreathProductElem: lengths differ"))

3
src/fallbacks.jl
View File

@ -1,6 +1,5 @@
# workarounds
Base.one(G::Generic.PermGroup) = Generic.Perm(G.n)
Base.one(r::NCRingElem) = one(parent(r))
Base.one(G::Generic.SymmetricGroup) = Generic.Perm(G.n)
# fallback definitions
# note: the user should implement those on type, when possible

2
test/AutGroup-tests.jl
View File

@ -1,6 +1,6 @@
@testset "Automorphisms" begin
G = PermutationGroup(Int8(4))
G = SymmetricGroup(Int8(4))
@testset "AutSymbol" begin
@test_throws MethodError Groups.AutSymbol(:a)

10
test/DirectPower-tests.jl
View File

@ -3,11 +3,11 @@
×(a,b) = Groups.DirectPower(a,b)
@testset "Constructors" begin
G = PermutationGroup(3)
G = SymmetricGroup(3)
@test Groups.DirectPowerGroup(G,2) isa AbstractAlgebra.Group
@test G×G isa AbstractAlgebra.Group
@test Groups.DirectPowerGroup(G,2) isa Groups.DirectPowerGroup{2, Generic.PermGroup{Int64}}
@test Groups.DirectPowerGroup(G,2) isa Groups.DirectPowerGroup{2, Generic.SymmetricGroup{Int64}}
@test (G×G)×G == DirectPowerGroup(G, 3)
@test (G×G)×G == (G×G)×G
@ -42,7 +42,7 @@
end
@testset "Basic arithmetic" begin
G = PermutationGroup(3)
G = SymmetricGroup(3)
GG = G×G
i = perm"(1,3)"
g = perm"(1,2,3)"
@ -65,7 +65,7 @@
end
@testset "elem/parent_types" begin
G = PermutationGroup(3)
G = SymmetricGroup(3)
g = perm"(1,2,3)"
@test elem_type(G×G) == DirectPowerGroupElem{2, elem_type(G)}
@ -75,7 +75,7 @@
end
@testset "Misc" begin
G = PermutationGroup(3)
G = SymmetricGroup(3)
GG = Groups.DirectPowerGroup(G,3)
@test order(GG) == 216

12
test/WreathProd-tests.jl
View File

@ -1,6 +1,6 @@
@testset "WreathProducts" begin
S_3 = PermutationGroup(3)
S_2 = PermutationGroup(2)
S_3 = SymmetricGroup(3)
S_2 = SymmetricGroup(2)
b = perm"(1,2,3)"
a = perm"(1,2)"
@ -8,7 +8,7 @@
@test Groups.WreathProduct(S_2, S_3) isa AbstractAlgebra.Group
B3 = Groups.WreathProduct(S_2, S_3)
@test B3 isa Groups.WreathProduct
@test B3 isa WreathProduct{3, Generic.PermGroup{Int}, Generic.PermGroup{Int}}
@test B3 isa WreathProduct{3, Generic.SymmetricGroup{Int}, Generic.SymmetricGroup{Int}}
aa = Groups.DirectPowerGroupElem((a^0 ,a, a^2))
@ -37,7 +37,7 @@
@test elem_type(B3) == Groups.WreathProductElem{3, Generic.Perm{Int}, Generic.Perm{Int}}
@test parent_type(typeof(one(B3))) == Groups.WreathProduct{3, parent_type(typeof(one(B3.N.group))), Generic.PermGroup{Int}}
@test parent_type(typeof(one(B3))) == Groups.WreathProduct{3, parent_type(typeof(one(B3.N.group))), Generic.SymmetricGroup{Int}}
@test parent(one(B3)) == Groups.WreathProduct(S_2,S_3)
@test parent(one(B3)) == B3
@ -64,7 +64,7 @@
end
@testset "Group arithmetic" begin
B4 = Groups.WreathProduct(PermutationGroup(3), PermutationGroup(4))
B4 = Groups.WreathProduct(SymmetricGroup(3), SymmetricGroup(4))
id, a, b = perm"(3)", perm"(1,2)(3)", perm"(1,2,3)"
@ -84,7 +84,7 @@
end
@testset "Iteration" begin
Wr = WreathProduct(PermutationGroup(2),PermutationGroup(4))
Wr = WreathProduct(SymmetricGroup(2),SymmetricGroup(4))
elts = collect(Wr)
@test elts isa Vector{Groups.WreathProductElem{4, Generic.Perm{Int}, Generic.Perm{Int}}}