Merge branch '1712.07167' of github.com:kalmarek/Groups.jl into 1712.07167

.travis.yml

@@ -4,7 +4,6 @@ os:
   - linux
   - osx
 julia:
-  - 0.5
   - 0.6
   - nightly
 notifications:
@@ -26,7 +25,7 @@ matrix:
 
 ## uncomment the following lines to override the default test script
 script:
-#  - julia -e 'Pkg.clone("https://github.com/Nemocas/Nemo.jl"); Pkg.build("Nemo")'
+  - julia -e 'Pkg.clone("https://github.com/Nemocas/Nemo.jl"); Pkg.build("Nemo")'
   - julia -e 'Pkg.clone(pwd()); Pkg.build("Groups"); Pkg.test("Groups"; coverage=true)'
 
 after_success:

REQUIRE

@@ -1,2 +1,2 @@
-julia 0.5
+julia 0.6
 Nemo

src/AutGroup.jl

@@ -19,7 +19,7 @@ immutable FlipAut
 end
 
 immutable PermAut
-    p::perm
+    p::Nemo.Generic.perm
 end
 
 immutable Identity end
@@ -30,9 +30,9 @@ immutable AutSymbol <: GSymbol
    typ::Union{RTransvect, LTransvect, FlipAut, PermAut, Identity}
 end
 
-typealias AutGroupElem GWord{AutSymbol}
+AutGroupElem = GWord{AutSymbol}
 
-type AutGroup <: AbstractFPGroup
+mutable struct AutGroup <: AbstractFPGroup
    objectGroup::Group
    gens::Vector{AutSymbol}
 end
@@ -104,7 +104,7 @@ function flip_autsymbol(i; pow::Int=1)
     end
 end
 
-function perm_autsymbol(p::perm; pow::Int=1)
+function perm_autsymbol(p::Generic.perm; pow::Int=1)
     p = p^pow
     if p == parent(p)()
        return id_autsymbol()

src/DirectProducts.jl

@@ -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) =
@@ -45,9 +45,9 @@ parent(g::DirectProductGroupElem) =
 ###############################################################################
 
 Base.size(g::DirectProductGroupElem) = size(g.elts)
-Base.linearindexing(::Type{DirectProductGroupElem}) = Base.LinearFast()
+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
 

src/FPGroups.jl

@@ -4,14 +4,14 @@
 #
 ###############################################################################
 
-immutable FPSymbol <: GSymbol
+struct FPSymbol <: GSymbol
    str::String
    pow::Int
 end
 
-typealias FPGroupElem GWord{FPSymbol}
+FPGroupElem = GWord{FPSymbol}
 
-type FPGroup <: AbstractFPGroup
+mutable struct FPGroup <: AbstractFPGroup
    gens::Vector{FPSymbol}
    rels::Dict{FPGroupElem, FPGroupElem}
 

src/FreeGroup.jl

@@ -4,14 +4,14 @@
 #
 ###############################################################################
 
-immutable FreeSymbol <: GSymbol
+struct FreeSymbol <: GSymbol
    str::String
    pow::Int
 end
 
-typealias FreeGroupElem GWord{FreeSymbol}
+FreeGroupElem = GWord{FreeSymbol}
 
-type FreeGroup <: AbstractFPGroup
+mutable struct FreeGroup <: AbstractFPGroup
    gens::Vector{FreeSymbol}
    #     order::Vector{T}
    #     fastmult_table::Array{Int,2}

src/Groups.jl

@@ -25,7 +25,7 @@ doc"""
 > * `pow` which is the (multiplicative) exponent of a symbol.
 
 """
-abstract GSymbol
+abstract type GSymbol end
 
 doc"""
     W::GWord{T<:GSymbol} <:GroupElem
@@ -43,18 +43,18 @@ doc"""
 
 """
 
-type GWord{T<:GSymbol} <: GroupElem
+mutable struct GWord{T<:GSymbol} <: GroupElem
-    symbols::Vector{T}
+   symbols::Vector{T}
-    savedhash::UInt
+   savedhash::UInt
-    modified::Bool
+   modified::Bool
-    parent::Group
+   parent::Group
 
-    function GWord(symbols::Vector{T})
+   function GWord{T}(symbols::Vector{T}) where {T}
-        return new(symbols, hash(symbols), true)
+      return new{T}(symbols, hash(symbols), true)
-    end
+   end
 end
 
-abstract AbstractFPGroup <: Group
+abstract type AbstractFPGroup <: Group end
 
 ###############################################################################
 #
@@ -70,8 +70,8 @@ parent{T<:GSymbol}(w::GWord{T}) = w.parent
 #
 ###############################################################################
 
-GWord{T<:GSymbol}(s::T) = 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])
 
 ###############################################################################
 #
@@ -79,19 +79,18 @@ convert{T<:GSymbol}(::Type{GWord{T}}, s::T) = GWord{T}(T[s])
 #
 ###############################################################################
 
-xor(a,b) = a $ b
-
 function hash(W::GWord, h::UInt)
     W.modified && reduce!(W)
-    return xor(W.savedhash, h)
+    res = xor(W.savedhash, h)
+    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])
 
@@ -162,7 +161,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
@@ -256,7 +255,7 @@ end
 #
 ###############################################################################
 
-function inv{T}(W::GWord{T})
+function inv(W::GWord{T}) where {T}
     if length(W) == 0
         return W
     else
@@ -352,7 +351,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]
@@ -366,8 +365,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},
+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)
    replace_all!(W, subst_dict)
    return W

src/WreathProducts.jl

@@ -17,29 +17,29 @@ doc"""
 
 # Arguments:
 * `::Group` : the single factor of group $N$
-* `::PermGroup` : full `PermutationGroup`
+* `::Generic.PermGroup` : full `PermutationGroup`
 """
-immutable WreathProduct{T<:Group} <: Group
+struct WreathProduct{T<:Group} <: Group
    N::DirectProductGroup{T}
-   P::PermGroup
+   P::Generic.PermGroup
 
-   function WreathProduct(G::Group, P::PermGroup)
+   function WreathProduct{T}(G::T, P::Generic.PermGroup) where {T}
       N = DirectProductGroup(G, P.n)
       return new(N, P)
    end
 end
 
-immutable WreathProductElem{T<:GroupElem} <: GroupElem
+struct WreathProductElem{T<:GroupElem} <: GroupElem
    n::DirectProductGroupElem{T}
-   p::perm
+   p::Generic.perm
    # parent::WreathProduct
 
-   function WreathProductElem(n::DirectProductGroupElem, p::perm,
+   function WreathProductElem{T}(n::DirectProductGroupElem{T}, p::Generic.perm,
-      check::Bool=true)
+      check::Bool=true) where {T}
       if check
          length(n.elts) == parent(p).n || throw("Can't form WreathProductElem: lengths differ")
       end
-      return new(n, p)
+      return new{T}(n, p)
    end
 end
 
@@ -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))
@@ -62,10 +62,9 @@ parent(g::WreathProductElem) = WreathProduct(parent(g.n[1]), parent(g.p))
 #
 ###############################################################################
 
-WreathProduct{T<:Group}(G::T, P::PermGroup) = WreathProduct{T}(G, P)
+WreathProduct(G::Gr, P::Generic.PermGroup) where {Gr} = WreathProduct{Gr}(G, P)
 
-WreathProductElem{T<:GroupElem}(n::DirectProductGroupElem{T},
+WreathProductElem(n::DirectProductGroupElem{T}, p, check=true) where {T} = WreathProductElem{T}(n, p, check)
-   p::perm, check::Bool=true) = WreathProductElem{T}(n, p, check)
 
 ###############################################################################
 #
@@ -88,19 +87,19 @@ function (G::WreathProduct)(g::WreathProductElem)
 end
 
 doc"""
-    (G::WreathProduct)(n::DirectProductGroupElem, p::perm)
+    (G::WreathProduct)(n::DirectProductGroupElem, p::Generic.perm)
 > Creates an element of wreath product `G` by coercing `n` and `p` to `G.N` and
 > `G.P`, respectively.
 """
-(G::WreathProduct)(n::DirectProductGroupElem, p::perm) = WreathProductElem(n,p)
+(G::WreathProduct)(n::DirectProductGroupElem, p::Generic.perm) = WreathProductElem(n,p)
 
 (G::WreathProduct)() = WreathProductElem(G.N(), G.P(), false)
 
 doc"""
-    (G::WreathProduct)(p::perm)
+    (G::WreathProduct)(p::Generic.perm)
 > Returns the image of permutation `p` in `G` via embedding `p -> (id,p)`.
 """
-(G::WreathProduct)(p::perm) = G(G.N(), p)
+(G::WreathProduct)(p::Generic.perm) = G(G.N(), p)
 
 doc"""
     (G::WreathProduct)(n::DirectProductGroupElem)
@@ -171,7 +170,7 @@ doc"""
 >
 > `g*h = (g.n*g.p(h.n), g.p*h.p)`,
 >
-> where `g.p(h.n)` denotes the action of `g.p::perm` on
+> where `g.p(h.n)` denotes the action of `g.p::Generic.perm` on
 > `h.n::DirectProductGroupElem` via standard permutation of coordinates.
 """
 function *(g::WreathProductElem, h::WreathProductElem)

test/FreeGroup-tests.jl

@@ -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])