extending svector, module etc to noncommutative

src/AbstractTypes.jl

@@ -6,7 +6,7 @@ abstract type Ring <: AbstractAlgebra.Ring end
 
 abstract type Field <: AbstractAlgebra.Field end
 
-abstract type Module{T <: AbstractAlgebra.RingElem} <: AbstractAlgebra.Module{T} end
+abstract type Module{T <: AbstractAlgebra.NCRingElem} <: AbstractAlgebra.Module{T} end
 
 abstract type Map <: AbstractAlgebra.SetMap end
 

src/Singular.jl

@@ -216,10 +216,10 @@ include("poly/PolyTypes.jl")
 
 include("matrix/MatrixTypes.jl")
 
-include("module/ModuleTypes.jl")
-
 include("poly/PluralTypes.jl")
 
+include("module/ModuleTypes.jl")
+
 include("poly/LPTypes.jl")
 
 # all "poly" types

src/module/ModuleTypes.jl

@@ -4,21 +4,27 @@
 #
 ###############################################################################
 
-const FreeModID = Dict{Tuple{PolyRing, Int}, Module}()
+const FreeModID = Dict{Tuple{Union{PolyRing,PluralRing}, Int}, Module}()
 
-mutable struct FreeMod{T <: Nemo.RingElem} <: Module{T}
- base_ring::PolyRing
+mutable struct FreeMod{T <: Union{Nemo.RingElem, Singular.spluralg}} <: Module{T}
+ base_ring::Union{PolyRing, PluralRing}
  rank::Int
 
  function FreeMod{T}(R::PolyRing, r::Int) where T
  return get!(FreeModID, (R, r)) do
  new(R, r)
  end
  end
+
+ function FreeMod{T}(R::Singular.PluralRing, r::Int) where T
+ return get!(FreeModID, (R, r)) do
+ new(R, r)
+ end
+ end
 end
 
-mutable struct svector{T <: Nemo.RingElem} <: Nemo.ModuleElem{T}
- base_ring::PolyRing
+mutable struct svector{T <: Union{Nemo.RingElem, Singular.spluralg}} <: Nemo.ModuleElem{T}
+ base_ring::Union{PolyRing, PluralRing}
  ptr::libSingular.poly_ptr # not really a polynomial
  rank::Int
 
@@ -29,6 +35,14 @@ mutable struct svector{T <: Nemo.RingElem} <: Nemo.ModuleElem{T}
  finalizer(_svector_clear_fn, z)
  return z
  end
+
+ function svector{T}(R::PluralRing, r::Int, p::libSingular.poly_ptr) where T
+ T === elem_type(R) || error("type mismatch")
+ z = new(R, p, r)
+ R.refcount += 1
+ finalizer(_svector_clear_fn, z)
+ return z
+ end
 end
 
 """
@@ -67,8 +81,8 @@ mutable struct ModuleClass{T <: Nemo.RingElem} <: Set
  end
 end
 
-mutable struct smodule{T <: Nemo.RingElem} <: Module{T}
- base_ring::PolyRing
+mutable struct smodule{T <: Union{Nemo.RingElem, spluralg}} <: Module{T}
+ base_ring::Union{PolyRing, PluralRing}
  ptr::libSingular.ideal_ptr # ideal and module types are the same in Singular
  isGB::Bool
 
@@ -80,6 +94,14 @@ mutable struct smodule{T <: Nemo.RingElem} <: Module{T}
  finalizer(_smodule_clear_fn, z)
  return z
  end
+
+ function smodule{T}(R::PluralRing, m::libSingular.ideal_ptr) where T
+ T === elem_type(R) || error("type mismatch")
+ z = new(R, m, false)
+ R.refcount += 1
+ finalizer(_smodule_clear_fn, z)
+ return z
+ end
 end
 
 # ownership of the pointer is NOT taken - not for general users
@@ -104,6 +126,21 @@ function smodule{T}(R::PolyRing, vecs::svector...) where T
  return z
 end
 
+function smodule{T}(R::PluralRing, vecs::svector...) where T
+ n = length(vecs)
+ r = vecs[1].rank;
+ for i = 1:n
+ @assert vecs[i].rank == r
+ end
+ m = libSingular.idInit(Cint(n), Cint(r))
+ z = smodule{T}(R, m)
+ for i = 1:n
+ v = libSingular.p_Copy(vecs[i].ptr, R.ptr)
+ libSingular.setindex_internal(m, v, Cint(i - 1))
+ end
+ return z
+end
+
 """
  (R::PolyRing{T})(m::libSingular.ideal,::Val{:module}) where T
 

src/module/module.jl

@@ -38,7 +38,7 @@ function checkbounds(I::smodule, i::Int)
  (i > ngens(I) || i < 1) && throw(BoundsError(I, i))
 end
 
-function getindex(I::smodule{T}, i::Int) where T <: AbstractAlgebra.RingElem
+function getindex(I::smodule{T}, i::Int) where T 
  checkbounds(I, i)
  R = base_ring(I)
  GC.@preserve I R begin
@@ -457,11 +457,21 @@ function Module(R::PolyRing{T}, vecs::svector{spoly{T}}...) where T <: Nemo.Ring
  return smodule{S}(R, vecs...)
 end
 
+function Module(R::PluralRing, vecs::svector{spluralg{T}}...) where T
+ S = elem_type(R)
+ return smodule{S}(R, vecs...)
+end
+
 function Module(R::PolyRing{T}, id::libSingular.ideal_ptr) where T <: Nemo.RingElem
  S = elem_type(R)
  return smodule{S}(R, id)
 end
 
+function Module(R::PluralRing, id::libSingular.ideal_ptr) 
+ S = elem_type(R)
+ return smodule{S}(R, id)
+end
+
 ###############################################################################
 #
 # Differential functions

src/module/vector.jl

@@ -6,7 +6,7 @@ export FreeMod, svector, gens, rank, vector, jet
 #
 ###############################################################################
 
-parent(v::svector{T}) where {T <: Nemo.RingElem} = FreeMod{T}(v.base_ring, v.rank)
+parent(v::svector{T}) where {T <: Union{Nemo.RingElem, spluralg}} = FreeMod{T}(v.base_ring, v.rank)
 
 base_ring(R::FreeMod) = R.base_ring
 
@@ -28,13 +28,13 @@ rank(M::FreeMod) = M.rank
 
 Return a Julia array whose entries are the generators of the given free module.
 """
-function gens(M::FreeMod{T}) where T <: AbstractAlgebra.RingElem
+function gens(M::FreeMod{T}) where T <: Union{AbstractAlgebra.RingElem, Singular.spluralg}
  R = base_ring(M)
  ptr = GC.@preserve R libSingular.id_FreeModule(Cint(M.rank), R.ptr)
  return [svector{T}(R, M.rank, libSingular.getindex(ptr, Cint(i - 1))) for i in 1:M.rank]
 end
 
-function gen(M::FreeMod{T}, i::Int) where T <: AbstractAlgebra.RingElem
+function gen(M::FreeMod{T}, i::Int) where T <: Union{AbstractAlgebra.RingElem, Singular.spluralg}
  1 <= i <= M.rank || error("index out of range")
  R = base_ring(M)
  ptr = GC.@preserve R libSingular.id_FreeModule(Cint(M.rank), R.ptr)
@@ -43,13 +43,13 @@ end
 
 number_of_generators(M::FreeMod{T}) where T <: AbstractAlgebra.RingElem = rank(M)
 
-function deepcopy_internal(p::svector{T}, dict::IdDict) where T <: AbstractAlgebra.RingElem
+function deepcopy_internal(p::svector{T}, dict::IdDict) where T <: Union{AbstractAlgebra.RingElem, Singular.spluralg}
  R = base_ring(p)
  p2 = GC.@preserve p R libSingular.p_Copy(p.ptr, R.ptr)
  return svector{T}(p.base_ring, p.rank, p2)
 end
 
-function check_parent(a::svector{T}, b::svector{T}) where T <: Nemo.RingElem
+function check_parent(a::svector{T}, b::svector{T}) where T <: Union{Nemo.RingElem, Singular.spluralg}
  base_ring(a) != base_ring(b) && error("Incompatible base rings")
  a.rank != b.rank && error("Vectors of incompatible rank")
 end
@@ -86,7 +86,7 @@ end
 #
 ###############################################################################
 
-function -(a::svector{T}) where T <: AbstractAlgebra.RingElem
+function -(a::svector{T}) where T <: Union{AbstractAlgebra.RingElem, spluralg}
  R = base_ring(a)
  GC.@preserve a R begin
  a1 = libSingular.p_Copy(a.ptr, R.ptr)
@@ -103,7 +103,7 @@ iszero(p::svector) = p.ptr.cpp_object == C_NULL
 #
 ###############################################################################
 
-function +(a::svector{T}, b::svector{T}) where T <: AbstractAlgebra.RingElem
+function +(a::svector{T}, b::svector{T}) where T <: Union{AbstractAlgebra.RingElem, spluralg}
  check_parent(a, b)
  R = base_ring(a)
  GC.@preserve a b R begin
@@ -114,7 +114,7 @@ function +(a::svector{T}, b::svector{T}) where T <: AbstractAlgebra.RingElem
  end
 end
 
-function -(a::svector{T}, b::svector{T}) where T <: AbstractAlgebra.RingElem
+function -(a::svector{T}, b::svector{T}) where T <: Union{AbstractAlgebra.RingElem, spluralg}
  check_parent(a, b)
  R = base_ring(a)
  GC.@preserve a b R begin
@@ -138,6 +138,13 @@ function *(a::svector{spoly{T}}, b::spoly{T}) where T <: AbstractAlgebra.RingEle
  return svector{spoly{T}}(R, a.rank, s)
 end
 
+function *(b::Singular.spluralg{T}, a::svector{Singular.spluralg{T}}) where T
+ base_ring(a) != parent(b) && error("Incompatible base rings")
+ R = base_ring(a)
+ s = GC.@preserve a b R libSingular.pp_Mult_qq(a.ptr, b.ptr, R.ptr)
+ return svector{spluralg{T}}(R, a.rank, s)
+end
+
 function (a::spoly{T} * b::svector{spoly{T}}) where T <: Nemo.RingElem
  base_ring(b) != parent(a) && error("Incompatible base rings")
  R = base_ring(b)
@@ -149,6 +156,8 @@ end
 
 (a::T * b::svector{spoly{T}}) where T <: Nemo.RingElem = base_ring(b)(a)*b
 
+#(a::Singular.spluralg * b::svector{Singular.spluralg}) = base_ring(b)(a)*b
+
 *(a::svector, b::Integer) = a*base_ring(a)(b)
 
 *(a::Integer, b::svector) = base_ring(b)(a)*b
@@ -159,7 +168,7 @@ end
 #
 ###############################################################################
 
-function (x::svector{T} == y::svector{T}) where T <: Nemo.RingElem
+function (x::svector{T} == y::svector{T}) where T <: Union{Nemo.RingElem, Singular.spluralg}
  check_parent(x, y)
  R = base_ring(x)
  GC.@preserve x y R return Bool(libSingular.p_EqualPolys(x.ptr, y.ptr, R.ptr))
@@ -188,7 +197,7 @@ end
 #
 ###############################################################################
 
-function (S::FreeMod{T})(a::Vector{T}) where T <: AbstractAlgebra.RingElem
+function (S::FreeMod{T})(a::Vector{T}) where T <: Union{AbstractAlgebra.RingElem, Singular.spluralg}
  R = base_ring(S) # polynomial ring
  GC.@preserve a R begin
  n = size(a)[1]
@@ -198,7 +207,7 @@ function (S::FreeMod{T})(a::Vector{T}) where T <: AbstractAlgebra.RingElem
  end
 end
 
-function (S::FreeMod{T})() where T <: AbstractAlgebra.RingElem
+function (S::FreeMod{T})() where T <: Union{AbstractAlgebra.RingElem, Singular.spluralg}
  R = base_ring(S) # polynomial ring
  n = S.rank
  z = zero(R)
@@ -245,6 +254,22 @@ function Base.iterate(p::svector{spoly{T}}) where T <: Nemo.RingElem
  end
 end
 
+function Base.iterate(p::Singular.svector{Singular.spluralg{T}}) where T 
+ GC.@preserve p begin
+ ptr = p.ptr
+ if ptr.cpp_object == C_NULL
+ return nothing
+ else
+ R = base_ring(p)
+ A = Array{Int}(undef, nvars(R))
+ c = GC.@preserve R libSingular.p_GetExpVLV(ptr, A, R.ptr)
+ S = base_ring(R)
+ a = GC.@preserve S S(libSingular.n_Copy(libSingular.pGetCoeff(ptr), S.ptr))
+ return (c, A, a), ptr
+ end
+ end
+end
+
 function Base.iterate(p::svector{spoly{T}}, state) where T <: Nemo.RingElem
  GC.@preserve p begin
  state = libSingular.pNext(state)
@@ -261,6 +286,22 @@ function Base.iterate(p::svector{spoly{T}}, state) where T <: Nemo.RingElem
  end
 end
 
+function Base.iterate(p::svector{spluralg{T}}, state) where T
+ GC.@preserve p begin
+ state = libSingular.pNext(state)
+ if state.cpp_object == C_NULL
+ return nothing
+ else
+ R = base_ring(p)
+ A = Array{Int}(undef, nvars(R))
+ c = GC.@preserve R libSingular.p_GetExpVLV(state, A, R.ptr)
+ S = base_ring(R)
+ a = GC.@preserve S S(libSingular.n_Copy(libSingular.pGetCoeff(state), S.ptr))
+ return (c, A, a), state
+ end
+ end
+end
+
 Base.IteratorSize(::svector{spoly{T}}) where {T} = Base.SizeUnknown()
 ###############################################################################
 #
@@ -291,6 +332,13 @@ function FreeModule(R::PolyRing{T}, n::Int) where T <: Nemo.RingElem
  return FreeMod{S}(R, n)
 end
 
+function FreeModule(R::Singular.PluralRing{T}, n::Int) where T <: Singular.n_Q
+ (n > typemax(Cint) || n < 0) &&
+ throw(DomainError(n, "rank must be non-negative and <= $(typemax(Cint))"))
+ S = elem_type(R)
+ return FreeMod{S}(R, n)
+end
+
 ###############################################################################
 #
 # Differential functions