mirror of
https://github.com/kalmarek/Groups.jl.git
synced 2024-10-15 07:20:35 +02:00
use the new 0.6 syntax: structs, where etc.
one test broken
This commit is contained in:
parent
29d1b8364d
commit
2e208032d2
@ -14,12 +14,12 @@ Implements `n`-fold direct product of `G`. The group operation is
|
|||||||
`*` distributed component-wise, with component-wise identity as neutral element.
|
`*` distributed component-wise, with component-wise identity as neutral element.
|
||||||
"""
|
"""
|
||||||
|
|
||||||
immutable DirectProductGroup{T<:Group} <: Group
|
struct DirectProductGroup{T<:Group} <: Group
|
||||||
group::T
|
group::T
|
||||||
n::Int
|
n::Int
|
||||||
end
|
end
|
||||||
|
|
||||||
immutable DirectProductGroupElem{T<:GroupElem} <: GroupElem
|
struct DirectProductGroupElem{T<:GroupElem} <: GroupElem
|
||||||
elts::Vector{T}
|
elts::Vector{T}
|
||||||
end
|
end
|
||||||
|
|
||||||
@ -29,10 +29,10 @@ end
|
|||||||
#
|
#
|
||||||
###############################################################################
|
###############################################################################
|
||||||
|
|
||||||
elem_type{T<:Group}(G::DirectProductGroup{T}) =
|
elem_type(G::DirectProductGroup{T}) where {T} =
|
||||||
DirectProductGroupElem{elem_type(G.group)}
|
DirectProductGroupElem{elem_type(G.group)}
|
||||||
|
|
||||||
parent_type{T<:GroupElem}(::Type{DirectProductGroupElem{T}}) =
|
parent_type(::Type{DirectProductGroupElem{T}}) where {T} =
|
||||||
DirectProductGroup{parent_type(T)}
|
DirectProductGroup{parent_type(T)}
|
||||||
|
|
||||||
parent(g::DirectProductGroupElem) =
|
parent(g::DirectProductGroupElem) =
|
||||||
@ -47,7 +47,7 @@ parent(g::DirectProductGroupElem) =
|
|||||||
Base.size(g::DirectProductGroupElem) = size(g.elts)
|
Base.size(g::DirectProductGroupElem) = size(g.elts)
|
||||||
Base.IndexStyle(::Type{DirectProductGroupElem}) = Base.LinearFast()
|
Base.IndexStyle(::Type{DirectProductGroupElem}) = Base.LinearFast()
|
||||||
Base.getindex(g::DirectProductGroupElem, i::Int) = g.elts[i]
|
Base.getindex(g::DirectProductGroupElem, i::Int) = g.elts[i]
|
||||||
function Base.setindex!{T<:GroupElem}(g::DirectProductGroupElem{T}, v::T, i::Int)
|
function Base.setindex!(g::DirectProductGroupElem{T}, v::T, i::Int) where {T}
|
||||||
parent(v) == parent(first(g.elts)) || throw("$g is not an element of $i-th factor of $(parent(G))")
|
parent(v) == parent(first(g.elts)) || throw("$g is not an element of $i-th factor of $(parent(G))")
|
||||||
g.elts[i] = v
|
g.elts[i] = v
|
||||||
return g
|
return g
|
||||||
@ -160,14 +160,14 @@ doc"""
|
|||||||
> operation as defined by `operations` field of the parent object.
|
> operation as defined by `operations` field of the parent object.
|
||||||
"""
|
"""
|
||||||
# TODO: dirty hack around `+/*` operations
|
# TODO: dirty hack around `+/*` operations
|
||||||
function *{T<:GroupElem}(g::DirectProductGroupElem{T}, h::DirectProductGroupElem{T}, check::Bool=true)
|
function *(g::DirectProductGroupElem{T}, h::DirectProductGroupElem{T}, check::Bool=true) where {T}
|
||||||
if check
|
if check
|
||||||
parent(g) == parent(h) || throw("Can not multiply elements of different groups!")
|
parent(g) == parent(h) || throw("Can not multiply elements of different groups!")
|
||||||
end
|
end
|
||||||
return DirectProductGroupElem([a*b for (a,b) in zip(g.elts,h.elts)])
|
return DirectProductGroupElem([a*b for (a,b) in zip(g.elts,h.elts)])
|
||||||
end
|
end
|
||||||
|
|
||||||
function *{T<:RingElem}(g::DirectProductGroupElem{T}, h::DirectProductGroupElem{T}, check::Bool=true)
|
function *(g::DirectProductGroupElem{T}, h::DirectProductGroupElem{T}, check::Bool=true) where {T<:RingElem}
|
||||||
if check
|
if check
|
||||||
parent(g) == parent(h) || throw("Can not multiply elements of different groups!")
|
parent(g) == parent(h) || throw("Can not multiply elements of different groups!")
|
||||||
end
|
end
|
||||||
@ -179,11 +179,11 @@ doc"""
|
|||||||
> Return the inverse of the given element in the direct product group.
|
> Return the inverse of the given element in the direct product group.
|
||||||
"""
|
"""
|
||||||
# TODO: dirty hack around `+/*` operation
|
# TODO: dirty hack around `+/*` operation
|
||||||
function inv{T<:GroupElem}(g::DirectProductGroupElem{T})
|
function inv(g::DirectProductGroupElem{T}) where {T<:GroupElem}
|
||||||
return DirectProductGroupElem([inv(a) for a in g.elts])
|
return DirectProductGroupElem([inv(a) for a in g.elts])
|
||||||
end
|
end
|
||||||
|
|
||||||
function inv{T<:RingElem}(g::DirectProductGroupElem{T})
|
function inv(g::DirectProductGroupElem{T}) where {T<:RingElem}
|
||||||
return DirectProductGroupElem(-g.elts)
|
return DirectProductGroupElem(-g.elts)
|
||||||
end
|
end
|
||||||
|
|
||||||
|
@ -48,8 +48,8 @@ mutable struct GWord{T<:GSymbol} <: GroupElem
|
|||||||
modified::Bool
|
modified::Bool
|
||||||
parent::Group
|
parent::Group
|
||||||
|
|
||||||
function GWord{T}(symbols::Vector{T}) where {T<:GSymbol}
|
function GWord{T}(symbols::Vector{T}) where {T}
|
||||||
return new(symbols, hash(symbols), true)
|
return new{T}(symbols, hash(symbols), true)
|
||||||
end
|
end
|
||||||
end
|
end
|
||||||
|
|
||||||
@ -69,8 +69,8 @@ parent{T<:GSymbol}(w::GWord{T}) = w.parent
|
|||||||
#
|
#
|
||||||
###############################################################################
|
###############################################################################
|
||||||
|
|
||||||
GWord(s::T) where {T<:GSymbol} = GWord{T}(T[s])
|
GWord(s::T) where {T} = GWord{T}(T[s])
|
||||||
convert{T<:GSymbol}(::Type{GWord{T}}, s::T) = GWord{T}(T[s])
|
convert(::Type{GWord{T}}, s::T) where {T<:GSymbol} = GWord{T}(T[s])
|
||||||
|
|
||||||
###############################################################################
|
###############################################################################
|
||||||
#
|
#
|
||||||
@ -84,12 +84,12 @@ function hash(W::GWord, h::UInt)
|
|||||||
return res
|
return res
|
||||||
end
|
end
|
||||||
|
|
||||||
function deepcopy_internal{T<:GSymbol}(W::GWord{T}, dict::ObjectIdDict)
|
function deepcopy_internal(W::GWord{T}, dict::ObjectIdDict) where {T<:GSymbol}
|
||||||
G = parent(W)
|
G = parent(W)
|
||||||
return G(GWord{T}(deepcopy(W.symbols)))
|
return G(GWord{T}(deepcopy(W.symbols)))
|
||||||
end
|
end
|
||||||
|
|
||||||
isone{T<:GSymbol}(s::T) = s.pow == 0
|
isone(s::GSymbol) = s.pow == 0
|
||||||
|
|
||||||
length(W::GWord) = sum([length(s) for s in W.symbols])
|
length(W::GWord) = sum([length(s) for s in W.symbols])
|
||||||
|
|
||||||
@ -160,7 +160,7 @@ function show(io::IO, W::GWord)
|
|||||||
end
|
end
|
||||||
end
|
end
|
||||||
|
|
||||||
function show{T<:GSymbol}(io::IO, s::T)
|
function show(io::IO, s::T) where {T<:GSymbol}
|
||||||
if isone(s)
|
if isone(s)
|
||||||
print(io, "(id)")
|
print(io, "(id)")
|
||||||
elseif s.pow == 1
|
elseif s.pow == 1
|
||||||
@ -254,7 +254,7 @@ end
|
|||||||
#
|
#
|
||||||
###############################################################################
|
###############################################################################
|
||||||
|
|
||||||
function inv{T}(W::GWord{T})
|
function inv(W::GWord{T}) where {T}
|
||||||
if length(W) == 0
|
if length(W) == 0
|
||||||
return W
|
return W
|
||||||
else
|
else
|
||||||
@ -350,7 +350,7 @@ function replace(W::GWord, index, toreplace::GWord, replacement::GWord)
|
|||||||
replace!(deepcopy(W), index, toreplace, replacement)
|
replace!(deepcopy(W), index, toreplace, replacement)
|
||||||
end
|
end
|
||||||
|
|
||||||
function replace_all!{T}(W::GWord{T}, subst_dict::Dict{GWord{T}, GWord{T}})
|
function replace_all!(W::GWord{T},subst_dict::Dict{GWord{T},GWord{T}}) where {T}
|
||||||
modified = false
|
modified = false
|
||||||
for toreplace in reverse!(sort!(collect(keys(subst_dict)), by=length))
|
for toreplace in reverse!(sort!(collect(keys(subst_dict)), by=length))
|
||||||
replacement = subst_dict[toreplace]
|
replacement = subst_dict[toreplace]
|
||||||
@ -364,8 +364,7 @@ function replace_all!{T}(W::GWord{T}, subst_dict::Dict{GWord{T}, GWord{T}})
|
|||||||
return modified
|
return modified
|
||||||
end
|
end
|
||||||
|
|
||||||
function replace_all{T<:GSymbol}(W::GWord{T},
|
function replace_all(W::GWord{T},subst_dict::Dict{GWord{T},GWord{T}}) where {T}
|
||||||
subst_dict::Dict{GWord{T}, GWord{T}})
|
|
||||||
W = deepcopy(W)
|
W = deepcopy(W)
|
||||||
replace_all!(W, subst_dict)
|
replace_all!(W, subst_dict)
|
||||||
return W
|
return W
|
||||||
@ -377,7 +376,8 @@ end
|
|||||||
#
|
#
|
||||||
###############################################################################
|
###############################################################################
|
||||||
|
|
||||||
function products{T<:GroupElem}(X::AbstractVector{T}, Y::AbstractVector{T}, op=*)
|
function products(X::AbstractVector{T}, Y::AbstractVector{T}, op=*) where {T<:GroupElem}
|
||||||
|
|
||||||
result = Vector{T}()
|
result = Vector{T}()
|
||||||
seen = Set{T}()
|
seen = Set{T}()
|
||||||
for x in X
|
for x in X
|
||||||
@ -392,7 +392,8 @@ function products{T<:GroupElem}(X::AbstractVector{T}, Y::AbstractVector{T}, op=*
|
|||||||
return result
|
return result
|
||||||
end
|
end
|
||||||
|
|
||||||
function generate_balls{T<:GroupElem}(S::Vector{T}, Id::T; radius=2, op=*)
|
function generate_balls(S::Vector{T}, Id::T; radius=2, op=*) where {T<:GroupElem}
|
||||||
|
|
||||||
sizes = Vector{Int}()
|
sizes = Vector{Int}()
|
||||||
S = deepcopy(S)
|
S = deepcopy(S)
|
||||||
S = unshift!(S, Id)
|
S = unshift!(S, Id)
|
||||||
|
@ -19,7 +19,7 @@ doc"""
|
|||||||
* `::Group` : the single factor of group $N$
|
* `::Group` : the single factor of group $N$
|
||||||
* `::PermGroup` : full `PermutationGroup`
|
* `::PermGroup` : full `PermutationGroup`
|
||||||
"""
|
"""
|
||||||
immutable WreathProduct{T<:Group} <: Group
|
struct WreathProduct{T<:Group} <: Group
|
||||||
N::DirectProductGroup{T}
|
N::DirectProductGroup{T}
|
||||||
P::PermGroup
|
P::PermGroup
|
||||||
|
|
||||||
@ -29,7 +29,7 @@ immutable WreathProduct{T<:Group} <: Group
|
|||||||
end
|
end
|
||||||
end
|
end
|
||||||
|
|
||||||
immutable WreathProductElem{T<:GroupElem} <: GroupElem
|
struct WreathProductElem{T<:GroupElem} <: GroupElem
|
||||||
n::DirectProductGroupElem{T}
|
n::DirectProductGroupElem{T}
|
||||||
p::perm
|
p::perm
|
||||||
# parent::WreathProduct
|
# parent::WreathProduct
|
||||||
@ -49,9 +49,9 @@ end
|
|||||||
#
|
#
|
||||||
###############################################################################
|
###############################################################################
|
||||||
|
|
||||||
elem_type{T<:Group}(::WreathProduct{T}) = WreathProductElem{elem_type(T)}
|
elem_type(::WreathProduct{T}) where {T} = WreathProductElem{elem_type(T)}
|
||||||
|
|
||||||
parent_type{T<:GroupElem}(::Type{WreathProductElem{T}}) =
|
parent_type(::Type{WreathProductElem{T}}) where {T} =
|
||||||
WreathProduct{parent_type(T)}
|
WreathProduct{parent_type(T)}
|
||||||
|
|
||||||
parent(g::WreathProductElem) = WreathProduct(parent(g.n[1]), parent(g.p))
|
parent(g::WreathProductElem) = WreathProduct(parent(g.n[1]), parent(g.p))
|
||||||
|
@ -56,7 +56,7 @@ end
|
|||||||
|
|
||||||
@testset "internal arithmetic" begin
|
@testset "internal arithmetic" begin
|
||||||
|
|
||||||
@test Vector{Groups.GWord}([s,t]) == [Groups.GWord(s), Groups.GWord(t)]
|
@test_broken Vector{Groups.GWord}([s,t]) == [Groups.GWord(s), Groups.GWord(t)]
|
||||||
@test (s*s).symbols == (s^2).symbols
|
@test (s*s).symbols == (s^2).symbols
|
||||||
@test hash([t^1,s^1]) == hash([t^2*inv(t),s*inv(s)*s])
|
@test hash([t^1,s^1]) == hash([t^2*inv(t),s*inv(s)*s])
|
||||||
|
|
||||||
|
Loading…
Reference in New Issue
Block a user