add ncring interface
This commit is contained in:
parent
37f9763fc3
commit
900709f5f2
|
|
@ -12,74 +12,6 @@ import Base: convert, show, hash, ==, +, -, *, ^, //, /, length, getindex, setin
|
|||
|
||||
export GroupRing, GroupRingElem, complete!, create_pm, star, aug, supp
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
# String I/O
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
function show(io::IO, A::GroupRing)
|
||||
print(io, "Group Ring of $(A.group)")
|
||||
end
|
||||
|
||||
function show(io::IO, X::GroupRingElem)
|
||||
RG = parent(X)
|
||||
T = eltype(X.coeffs)
|
||||
if X.coeffs == zero(X.coeffs)
|
||||
print(io, "$(zero(T))*$((RG.group)())")
|
||||
elseif isdefined(RG, :basis)
|
||||
non_zeros = ((X.coeffs[i], RG.basis[i]) for i in findall(!iszero, X.coeffs))
|
||||
elts = String[]
|
||||
for (c,g) in non_zeros
|
||||
sgn = (sign(c)>=0 ? " + " : " - ")
|
||||
if c == T(1)
|
||||
coeff = ""
|
||||
else
|
||||
coeff = "$(abs(c))"
|
||||
end
|
||||
push!(elts, sgn*coeff*"$(g)")
|
||||
end
|
||||
str = join(elts, "")
|
||||
if sign(first(non_zeros)[1]) > 0
|
||||
str = str[4:end]
|
||||
end
|
||||
print(io, str)
|
||||
else
|
||||
@warn("Basis of the parent Group is not defined, showing coeffs")
|
||||
show(io, MIME("text/plain"), X.coeffs)
|
||||
end
|
||||
end
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
# Comparison
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
function (==)(X::GroupRingElem, Y::GroupRingElem)
|
||||
if eltype(X.coeffs) != eltype(Y.coeffs)
|
||||
@warn("Comparing elements with different coeffs Rings!")
|
||||
end
|
||||
suppX = supp(X)
|
||||
suppX == supp(Y) || return false
|
||||
|
||||
for g in suppX
|
||||
X[g] == Y[g] || return false
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
function (==)(A::GroupRing, B::GroupRing)
|
||||
A.group == B.group || return false
|
||||
if isdefined(A, :basis) && isdefined(B, :basis)
|
||||
A.basis == B.basis || return false
|
||||
elseif isdefined(A, :pm) && isdefined(B, :pm)
|
||||
A.pm == B.pm || return false
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
|
||||
function reverse_dict(::Type{I}, iter) where I<:Integer
|
||||
length(iter) > typemax(I) && error("Can not produce reverse dict: $(length(iter)) is too large for $T")
|
||||
|
|
|
|||
|
|
@ -0,0 +1,123 @@
|
|||
###############################################################################
|
||||
#
|
||||
# NCRing Interface
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
AbstractAlgebra.parent_type(::Type{GroupRingElem{T, GR}}) where {T, GR} = GR
|
||||
|
||||
function AbstractAlgebra.elem_type(::Type{<:GroupRing{R,G,El}}) where {R,G,El}
|
||||
return GroupRingElem{elem_type(R), GroupRing{R,G,El}}
|
||||
end
|
||||
|
||||
AbstractAlgebra.base_ring(RG::GroupRing) = RG.base_ring
|
||||
|
||||
AbstractAlgebra.parent(X::GroupRingElem) = X.parent
|
||||
|
||||
AbstractAlgebra.isexact_type(::Type{<:GroupRingElem{T}}) where T = isexact_type(T)
|
||||
|
||||
# hash(GroupRingElem) = 0x839279ac6f12f62a
|
||||
function Base.hash(X::GroupRingElem, h::UInt)
|
||||
return ⊻(hash(X.coeffs, h), hash(parent(X), h), 0x839279ac6f12f62a)
|
||||
end
|
||||
|
||||
function Base.deepcopy_internal(X::GroupRingElem, dict::IdDict)
|
||||
return parent(X)(deepcopy(X.coeffs))
|
||||
end
|
||||
|
||||
Base.zero(RG::GroupRing) = RG(0)
|
||||
Base.one(RG::GroupRing) = RG(1)
|
||||
Base.iszero(X::GroupRingElem{T}) where T = all(x == zero(T) for x in X.coeffs.nzval)
|
||||
|
||||
function Base.isone(X::GroupRingElem{T}) where T
|
||||
idx = _identity_idx(parent(X))
|
||||
X[idx] == one(T) || return false
|
||||
all(X[i] == zero(T) for i in eachindex(X.coeffs) if i != idx) || return false
|
||||
return true
|
||||
end
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
# String I/O
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
Base.show(io::IO, RG::GroupRing) =
|
||||
print(io, "Group ring of $(RG.group) with coefficients in $(base_ring(RG))")
|
||||
|
||||
function Base.show(io::IO, X::GroupRingElem{T}) where T
|
||||
RG = parent(X)
|
||||
if iszero(X)
|
||||
print(io, "$(zero(T))*$(multiplicative_id(RG.group))")
|
||||
elseif hasbasis(RG)
|
||||
suppX = supp(X)
|
||||
elts = String[]
|
||||
|
||||
elts = String[]
|
||||
sgn = ""
|
||||
for g in suppX
|
||||
coeff = X[g]
|
||||
if X[g] < 0
|
||||
sgn = " - "
|
||||
coeff = -coeff
|
||||
end
|
||||
push!(elts, sgn*string(coeff)*string(g))
|
||||
sgn = " + "
|
||||
end
|
||||
str = join(elts, "")
|
||||
print(io, str)
|
||||
else
|
||||
@warn("Basis of the parent group ring is not defined, showing coeffs")
|
||||
show(io, MIME("text/plain"), X.coeffs)
|
||||
end
|
||||
end
|
||||
|
||||
AbstractAlgebra.needs_parentheses(X::GroupRingElem) = true
|
||||
AbstractAlgebra.displayed_with_minus_in_front(X::GroupRingElem) = false
|
||||
AbstractAlgebra.show_minus_one(::Type{<:GroupRingElem}) = true
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
# Comparison
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
function ==(X::GroupRingElem{T}, Y::GroupRingElem{S}) where {T,S}
|
||||
if promote_type(T,S) ≠ T || promote_type(T,S) ≠ S
|
||||
@warn "Comparing elements with incompatible coeffs Rings: $T and $S can be only compared as $(promote_type(T,S))"
|
||||
end
|
||||
length(X.coeffs) == length(Y.coeffs) || return false
|
||||
parent(X).group == parent(Y).group || return false
|
||||
return all(x == y for (x,y) in zip(X.coeffs, Y.coeffs))
|
||||
end
|
||||
|
||||
Base.isequal(X::GroupRingElem, Y::GroupRingElem) = X == Y
|
||||
|
||||
_equalorzero(x,y) = x == y || x == 0 || y == 0
|
||||
|
||||
function ==(A::GroupRing, B::GroupRing)
|
||||
A.group == B.group || return false
|
||||
# base_ring(A) == base_ring(B) || return false
|
||||
|
||||
bases = hasbasis(A) && hasbasis(B)
|
||||
caches = cachesmultiplication(A) && cachesmultiplication(B)
|
||||
|
||||
if bases && caches
|
||||
length(A) == length(B) || return false
|
||||
size(A.pm) == size(B.pm) || return false
|
||||
all(A.basis[i] == B.basis[i] for i in eachindex(A.basis)) || return false
|
||||
all(_equalorzero(A.pm[i], B.pm[i]) for i in eachindex(A.pm)) || return false
|
||||
return true
|
||||
elseif bases # && !caches
|
||||
length(A) == length(B) || return false
|
||||
all(A.basis[i] == B.basis[i] for i in eachindex(A.basis)) || return false
|
||||
return true
|
||||
elseif caches # && !bases
|
||||
size(A.pm) == size(B.pm) || return false
|
||||
all(A.pm[i] == B.pm[i] for i in eachindex(A.pm)) || return false
|
||||
return true
|
||||
else
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
Loading…
Reference in New Issue