From e69f5d13b6af23e8c353786a42820316a73b3056 Mon Sep 17 00:00:00 2001
From: kalmar <kalmar@amu.edu.pl>
Date: Thu, 26 Jan 2017 10:28:41 +0100
Subject: [PATCH] Splitted into Groups.jl package

---
 FreeGroups.jl |  25 --------
 Groups.jl     | 173 --------------------------------------------------
 2 files changed, 198 deletions(-)
 delete mode 100644 FreeGroups.jl
 delete mode 100644 Groups.jl

diff --git a/FreeGroups.jl b/FreeGroups.jl
deleted file mode 100644
index 2ac223c..0000000
--- a/FreeGroups.jl
+++ /dev/null
@@ -1,25 +0,0 @@
-module FreeGroups
-
-using Groups
-
-import Base: inv, convert
-
-export FGSymbol, IDSymbol
-
-immutable FGSymbol <: GSymbol
-    gen::String
-    pow::Int
-end
-
-IDSymbol(::Type{FGSymbol}) = FGSymbol("(id)", 0)
-FGSymbol(x::String) = FGSymbol(x,1)
-
-inv(s::FGSymbol) = FGSymbol(s.gen, -s.pow)
-convert(::Type{FGSymbol}, x::String) = FGSymbol(x)
-change_pow(s::FGSymbol, n::Int) = reduce(FGSymbol(s.gen, n))
-
-typealias FGWord GWord{FGSymbol}
-
-FGWord(s::FGSymbol) = FGWord([s])
-
-end #end of module FreeGroups
diff --git a/Groups.jl b/Groups.jl
deleted file mode 100644
index 0b9045a..0000000
--- a/Groups.jl
+++ /dev/null
@@ -1,173 +0,0 @@
-module Groups
-
-import Base: length, ==, hash, show
-import Base: one, inv, reduce, *, ^
-
-export GSymbol, GWord
-
-export IdSymbol, change_pow
-
-abstract GSymbol
-
-function show(io::IO, s::GSymbol)
-    if s.pow == 0
-        print(io, "(id)")
-    elseif s.pow == 1
-        print(io, s.gen)
-    else
-        print(io, (s.gen)*"^$(s.pow)")
-    end
-end
-
-length(s::GSymbol) = (s.pow == 0 ? 0 : 1)
-
-IdSymbol(T::Type{GSymbol}) = throw(ArgumentError("Define IdSymbol(::Type{$T}) which is the identity element for Your type!"))
-
-one{T<:GSymbol}(::Type{T}) = IdSymbol(T)
-one(s::GSymbol) = one(typeof(s))
-
-(*){T<:GSymbol}(s::T, t::T) = return GWord{T}([s])*t
-
-change_pow(s::GSymbol, n::Int) = throw(ArgumentError("Define change_pow function for $(typeof(s))!"))
-
-
-abstract Word
-
-type GWord{T<:GSymbol} <: Word
-    symbols::Vector{T}
-    savedhash::UInt
-    modified::Bool
-
-    function GWord(symbols::Vector{T})
-        return new(symbols, hash(symbols), false)
-    end
-end
-
-GWord{T<:GSymbol}(s::T) = GWord{T}([s])
-
-IDWord{T<:GSymbol}(::Type{T}) = GWord(one(T))
-IDWord{T<:GSymbol}(W::GWord{T}) = IDWord(T)
-
-function length(W::GWord)
-    return sum([abs(s.pow) for s in W.symbols])
-end
-
-one{T}(::Type{GWord{T}}) = IDWord(T)
-one{T}(w::GWord{T}) = one(GWord{T})
-
-function inv{T}(W::GWord{T})
-    if length(W) == 0
-        return W
-    else
-        return freegroup_reduce!(GWord{T}(reverse([inv(s) for s in W.symbols])))
-    end
-end
-
-function join_free_symbols!(W::GWord)
-    reduced = true
-    for i in 1:length(W.symbols) - 1
-        if W.symbols[i].gen == W.symbols[i+1].gen
-            reduced = false
-            p1 = W.symbols[i].pow
-            p2 = W.symbols[i+1].pow
-            W.symbols[i+1] = change_pow(W.symbols[i], p1 + p2)
-            W.symbols[i] = one(W.symbols[i])
-        end
-    end
-    return reduced
-end
-
-function freegroup_reduce!{T}(W::GWord{T})
-    if length(W) < 2
-        deleteat!(W.symbols, find(x -> x.pow == 0, W.symbols))
-    else
-        reduced = false
-        while !reduced
-            reduced = join_free_symbols!(W)
-            deleteat!(W.symbols, find(x -> x.pow == 0, W.symbols))
-        end
-    end
-
-    W.modified = false
-    W.savedhash = hash(W.symbols,hash(typeof(W)))
-    return W
-end
-
-freegroup_reduce(W::GWord) = freegroup_reduce!(deepcopy(W))
-
-hash{T}(W::GWord{T}) = (W.modified && freegroup_reduce!(W); W.savedhash)
-
-function (==){T}(W::GWord{T}, Z::GWord{T})
-     W.modified && freegroup_reduce!(W) # reduce could actually clear the flag and recalculate the hash
-     Z.modified && freegroup_reduce!(Z)
-     return W.savedhash == Z.savedhash && W.symbols == Z.symbols
-end
-
-function show(io::IO, W::GWord)
-    if length(W) == 0
-        print(io, "(id)")
-    else
-        join(io, [string(s) for s in W.symbols], "*")
-    end
-end
-
-function r_multiply!(W::GWord, x; reduced::Bool=true)
-    if length(x) > 0
-        push!(W.symbols, x...)
-    end
-    if reduced
-        freegroup_reduce!(W)
-    end
-    return W
-end
-
-function l_multiply!(W::GWord, x; reduced::Bool=true)
-    if length(x) > 0
-        unshift!(W.symbols, reverse(x)...)
-    end
-    if reduced
-        freegroup_reduce!(W)
-    end
-    return W
-end
-
-r_multiply(W::GWord, x; reduced::Bool=true) =
-    r_multiply!(deepcopy(W),x, reduced=reduced)
-l_multiply(W::GWord, x; reduced::Bool=true) =
-    l_multiply!(deepcopy(W),x, reduced=reduced)
-
-(*){T}(W::GWord{T}, Z::GWord{T}) = r_multiply(W, Z.symbols)
-(*)(W::GWord, s::GSymbol) = W*GWord(s)
-(*)(s::GSymbol, W::GWord) = GWord(s)*W
-
-function power_by_squaring{T}(x::GWord{T}, p::Integer)
-    if p < 0
-        return power_by_squaring(inv(x), -p)
-    elseif p == 0
-        return one(x)
-    elseif p == 1
-        return deepcopy(x)
-    elseif p == 2
-        return x*x
-    end
-    t = trailing_zeros(p) + 1
-    p >>= t
-    while (t -= 1) > 0
-        x *= x
-    end
-    y = x
-    while p > 0
-        t = trailing_zeros(p) + 1
-        p >>= t
-        while (t -= 1) >= 0
-            x *= x
-        end
-        y *= x
-    end
-    return freegroup_reduce!(y)
-end
-
-(^)(x::GWord, n::Integer) = power_by_squaring(x,n)
-
-
-end