kalmar
/
Groups.jl
mirror of https://github.com/kalmarek/Groups.jl.git
1
0
Fork 0
Code Issues Releases Wiki Activity

use the new 0.6 syntax: structs, where etc. 

one test broken
This commit is contained in:
kalmarek 2017-09-13 16:47:31 +02:00
parent 29d1b8364d
commit 2e208032d2
4 changed files with 28 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/DirectProducts.jl
View File

@ -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.
"""
immutable DirectProductGroup{T<:Group} <: Group
struct DirectProductGroup{T<:Group} <: Group
group::T
n::Int
end
immutable DirectProductGroupElem{T<:GroupElem} <: GroupElem
struct DirectProductGroupElem{T<:GroupElem} <: GroupElem
elts::Vector{T}
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)}
parent_type{T<:GroupElem}(::Type{DirectProductGroupElem{T}}) =
parent_type(::Type{DirectProductGroupElem{T}}) where {T} =
DirectProductGroup{parent_type(T)}
parent(g::DirectProductGroupElem) =
@ -47,7 +47,7 @@ parent(g::DirectProductGroupElem) =
Base.size(g::DirectProductGroupElem) = size(g.elts)
Base.IndexStyle(::Type{DirectProductGroupElem}) = Base.LinearFast()
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))")
g.elts[i] = v
return g
@ -160,14 +160,14 @@ doc"""
> operation as defined by `operations` field of the parent object.
"""
# 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
parent(g) == parent(h) || throw("Can not multiply elements of different groups!")
end
return DirectProductGroupElem([a*b for (a,b) in zip(g.elts,h.elts)])
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
parent(g) == parent(h) || throw("Can not multiply elements of different groups!")
end
@ -179,11 +179,11 @@ doc"""
> Return the inverse of the given element in the direct product group.
"""
# 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])
end
function inv{T<:RingElem}(g::DirectProductGroupElem{T})
function inv(g::DirectProductGroupElem{T}) where {T<:RingElem}
return DirectProductGroupElem(-g.elts)
end

27
src/Groups.jl
View File

@ -48,8 +48,8 @@ mutable struct GWord{T<:GSymbol} <: GroupElem
modified::Bool
parent::Group
function GWord{T}(symbols::Vector{T}) where {T<:GSymbol}
return new(symbols, hash(symbols), true)
function GWord{T}(symbols::Vector{T}) where {T}
return new{T}(symbols, hash(symbols), true)
end
end
@ -69,8 +69,8 @@ parent{T<:GSymbol}(w::GWord{T}) = w.parent
#
###############################################################################
GWord(s::T) where {T<:GSymbol} = GWord{T}(T[s])
convert{T<:GSymbol}(::Type{GWord{T}}, s::T) = GWord{T}(T[s])
GWord(s::T) where {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
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)
return G(GWord{T}(deepcopy(W.symbols)))
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])
@ -160,7 +160,7 @@ function show(io::IO, W::GWord)
end
end
function show{T<:GSymbol}(io::IO, s::T)
function show(io::IO, s::T) where {T<:GSymbol}
if isone(s)
print(io, "(id)")
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
return W
else
@ -350,7 +350,7 @@ function replace(W::GWord, index, toreplace::GWord, replacement::GWord)
replace!(deepcopy(W), index, toreplace, replacement)
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
for toreplace in reverse!(sort!(collect(keys(subst_dict)), by=length))
replacement = subst_dict[toreplace]
@ -364,8 +364,7 @@ function replace_all!{T}(W::GWord{T}, subst_dict::Dict{GWord{T}, GWord{T}})
return modified
end
function replace_all{T<:GSymbol}(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}
W = deepcopy(W)
replace_all!(W, subst_dict)
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}()
seen = Set{T}()
for x in X
@ -392,7 +392,8 @@ function products{T<:GroupElem}(X::AbstractVector{T}, Y::AbstractVector{T}, op=*
return result
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}()
S = deepcopy(S)
S = unshift!(S, Id)

8
src/WreathProducts.jl
View File

@ -19,7 +19,7 @@ doc"""
* `::Group` : the single factor of group $N$
* `::PermGroup` : full `PermutationGroup`
"""
immutable WreathProduct{T<:Group} <: Group
struct WreathProduct{T<:Group} <: Group
N::DirectProductGroup{T}
P::PermGroup
@ -29,7 +29,7 @@ immutable WreathProduct{T<:Group} <: Group
end
end
immutable WreathProductElem{T<:GroupElem} <: GroupElem
struct WreathProductElem{T<:GroupElem} <: GroupElem
n::DirectProductGroupElem{T}
p::perm
# 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)}
parent(g::WreathProductElem) = WreathProduct(parent(g.n[1]), parent(g.p))

2
test/FreeGroup-tests.jl
View File

@ -56,7 +56,7 @@ end
@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 hash([t^1,s^1]) == hash([t^2*inv(t),s*inv(s)*s])