Add coefficient_ring_type (#2086)

fingolfin · web-flow · commit d76bdf0c6c74 · 2025-05-21T15:27:13.000+02:00
diff --git a/src/FreeAssociativeAlgebra.jl b/src/FreeAssociativeAlgebra.jl
@@ -10,6 +10,7 @@
 #
 ###############################################################################
 
+coefficient_ring_type(T::Type{<:FreeAssociativeAlgebra}) = base_ring_type(T)
 coefficient_ring(R::FreeAssociativeAlgebra{T}) where T <: RingElement = base_ring(R)
 
 function is_domain_type(::Type{S}) where {T <: RingElement, S <: FreeAssociativeAlgebraElem{T}}
diff --git a/src/MPoly.jl b/src/MPoly.jl
@@ -12,6 +12,7 @@
 
 base_ring_type(::Type{<:MPolyRing{T}}) where T<:RingElement = parent_type(T)
 
+coefficient_ring_type(T::Type{<:MPolyRing}) = base_ring_type(T)
 coefficient_ring(R::MPolyRing) = base_ring(R)
 
 @doc raw"""
diff --git a/src/NCPoly.jl b/src/NCPoly.jl
@@ -12,6 +12,7 @@
 
 base_ring_type(::Type{<:NCPolyRing{T}}) where T<:NCRingElement = parent_type(T)
 
+coefficient_ring_type(T::Type{<:NCPolyRing}) = base_ring_type(T)
 coefficient_ring(R::NCPolyRing) = base_ring(R)
 
 function is_exact_type(a::Type{T}) where {S <: NCRingElem, T <: NCPolyRingElem{S}}
diff --git a/src/Poly.jl b/src/Poly.jl
@@ -12,6 +12,7 @@
 
 base_ring_type(::Type{<:PolyRing{T}}) where T<:RingElement = parent_type(T)
 
+coefficient_ring_type(T::Type{<:PolyRing}) = base_ring_type(T)
 coefficient_ring(R::PolyRing) = base_ring(R)
 
 dense_poly_type(::Type{T}) where T<:RingElement = Generic.Poly{T}
diff --git a/src/exports.jl b/src/exports.jl
@@ -154,6 +154,7 @@ export check_parent
 export codomain
 export coeff
 export coefficient_ring
+export coefficient_ring_type
 export coefficients
 export coefficients_of_univariate
 export collength
diff --git a/src/fundamental_interface.jl b/src/fundamental_interface.jl
@@ -130,6 +130,12 @@ base_ring_type(T::DataType) = throw(MethodError(base_ring_type, (T,)))
 # generic coefficient_ring method
 coefficient_ring(x::NCRingElement) = coefficient_ring(parent(x))
 
+coefficient_ring_type(x) = coefficient_ring_type(typeof(x))
+coefficient_ring_type(x::Type{<:NCRingElement}) = coefficient_ring_type(parent_type(x))
+coefficient_ring_type(x::Type{<:ModuleElem}) = coefficient_ring_type(parent_type(x))
+coefficient_ring_type(x::Type{<:Ideal}) = coefficient_ring_type(parent_type(x))
+coefficient_ring_type(T::DataType) = throw(MethodError(coefficient_ring_type, (T,)))
+
 ###############################################################################
 #
 #   Special elements
diff --git a/src/generic/LaurentMPoly.jl b/src/generic/LaurentMPoly.jl
@@ -18,15 +18,14 @@ elem_type(::Type{LaurentMPolyWrapRing{T, PR}}) where {T, PR} =
 parent(p::LaurentMPolyWrap) = p.parent
 
 base_ring_type(::Type{<:LaurentMPolyWrapRing{T}}) where {T} = parent_type(T)
-
 base_ring(R::LaurentMPolyWrapRing) = base_ring(R.mpolyring)::base_ring_type(R)
 
+coefficient_ring_type(::Type{LaurentMPolyWrapRing{T, PR}}) where {T, PR} = coefficient_ring_type(PR)
 coefficient_ring(R::LaurentMPolyWrapRing) = coefficient_ring(R.mpolyring)
 
 symbols(R::LaurentMPolyWrapRing) = symbols(R.mpolyring)
 
 number_of_variables(R::LaurentMPolyWrapRing) = number_of_variables(R.mpolyring)
-
 number_of_generators(R::LaurentMPolyWrapRing) = number_of_variables(R.mpolyring)
 
 characteristic(R::LaurentMPolyWrapRing) = characteristic(R.mpolyring)
diff --git a/src/generic/LaurentPoly.jl b/src/generic/LaurentPoly.jl
@@ -17,12 +17,12 @@ elem_type(::Type{LaurentPolyWrapRing{T, PR}}) where {T, PR} =
 
 parent(p::LaurentPolyWrap) = p.parent
 
-coefficient_ring(R::LaurentPolyWrapRing) = coefficient_ring(R.polyring)
-
 base_ring_type(::Type{<:LaurentPolyWrapRing{T}}) where {T} = parent_type(T)
-
 base_ring(R::LaurentPolyWrapRing) = base_ring(R.polyring)::base_ring_type(R)
 
+coefficient_ring_type(::Type{LaurentPolyWrapRing{T, PR}}) where {T, PR} = coefficient_ring_type(PR)
+coefficient_ring(R::LaurentPolyWrapRing) = coefficient_ring(R.polyring)
+
 var(R::LaurentPolyWrapRing) = var(R.polyring)
 
 symbols(R::LaurentPolyWrapRing) = symbols(R.polyring)
diff --git a/src/generic/UnivPoly.jl b/src/generic/UnivPoly.jl
@@ -11,9 +11,9 @@
 ###############################################################################
 
 base_ring_type(::Type{<:UniversalPolyRing{T}}) where T = parent_type(T)
-
 base_ring(S::UniversalPolyRing) = S.base_ring::base_ring_type(S)
 
+coefficient_ring_type(T::Type{<:UniversalPolyRing}) = base_ring_type(T)
 coefficient_ring(S::UniversalPolyRing) = base_ring(S)
 
 function is_domain_type(::Type{<:UnivPoly{S}}) where {S <: RingElement}
diff --git a/src/generic/imports.jl b/src/generic/imports.jl
@@ -108,6 +108,7 @@ import ..AbstractAlgebra: check_parent
 import ..AbstractAlgebra: codomain
 import ..AbstractAlgebra: coeff
 import ..AbstractAlgebra: coefficient_ring
+import ..AbstractAlgebra: coefficient_ring_type
 import ..AbstractAlgebra: coefficients
 import ..AbstractAlgebra: coefficients_of_univariate
 import ..AbstractAlgebra: compose
diff --git a/test/generic/FreeAssociativeAlgebra-test.jl b/test/generic/FreeAssociativeAlgebra-test.jl
@@ -20,6 +20,7 @@
       @test parent_type(Generic.FreeAssociativeAlgebraElem{elem_type(R)}) == Generic.FreeAssociativeAlgebra{elem_type(R)}
       @test base_ring(S) === R
       @test coefficient_ring(S) === R
+      @test coefficient_ring_type(S) === typeof(R)
       @test ngens(S) == length(gens(S))
 
       @test S isa Generic.FreeAssociativeAlgebra
diff --git a/test/generic/LaurentMPoly-test.jl b/test/generic/LaurentMPoly-test.jl
@@ -14,8 +14,10 @@ end
 
     @test base_ring(L) == GF(5)
     @test coefficient_ring(L) == GF(5)
+    @test coefficient_ring_type(L) === typeof(GF(5))
     @test base_ring(x) == GF(5)
     @test coefficient_ring(x) == GF(5)
+    @test coefficient_ring_type(x) === typeof(GF(5))
 
     L, (x, y) = laurent_polynomial_ring(GF(5), ["x", "y"])
     @test L == laurent_polynomial_ring(GF(5), ['x', 'y'])[1]
diff --git a/test/generic/LaurentPoly-test.jl b/test/generic/LaurentPoly-test.jl
@@ -37,6 +37,8 @@ using AbstractAlgebra.Generic: Integers, LaurentPolyWrapRing, LaurentPolyWrap,
 
          @test base_ring(L) == R
          @test base_ring(L) == base_ring(P)
+         @test coefficient_ring(L) == R
+         @test coefficient_ring_type(L) === typeof(R)
 
          @test var(L) == :y
          @test symbols(L) == [:y]
diff --git a/test/generic/MPoly-test.jl b/test/generic/MPoly-test.jl
@@ -17,6 +17,7 @@
       @test parent_type(Generic.MPoly{elem_type(R)}) == Generic.MPolyRing{elem_type(R)}
       @test base_ring(S) === R
       @test coefficient_ring(S) === R
+      @test coefficient_ring_type(S) === typeof(R)
 
       @test S isa Generic.MPolyRing
 
diff --git a/test/generic/NCPoly-test.jl b/test/generic/NCPoly-test.jl
@@ -9,6 +9,7 @@
    for (S, y) in (S1, S2)
       @test base_ring(S) === R
       @test coefficient_ring(S) === R
+      @test coefficient_ring_type(S) === typeof(R)
       @test elem_type(S) == Generic.NCPoly{elem_type(R)}
       @test elem_type(Generic.NCPolyRing{elem_type(R)}) == Generic.NCPoly{elem_type(R)}
       @test parent_type(Generic.NCPoly{elem_type(R)}) == Generic.NCPolyRing{elem_type(R)}
diff --git a/test/generic/Poly-test.jl b/test/generic/Poly-test.jl
@@ -38,6 +38,7 @@ end
    for (S, y) in (S1, S2)
       @test base_ring(S) === R
       @test coefficient_ring(S) === R
+      @test coefficient_ring_type(S) === typeof(R)
 
       @test elem_type(S) == Generic.Poly{elem_type(R)}
       @test elem_type(Generic.PolyRing{elem_type(R)}) == Generic.Poly{elem_type(R)}
diff --git a/test/generic/UnivPoly-test.jl b/test/generic/UnivPoly-test.jl
@@ -31,6 +31,7 @@
 
          @test base_ring(S) === R
          @test coefficient_ring(S) === R
+         @test coefficient_ring_type(S) === typeof(R)
 
          @test S isa Generic.UniversalPolyRing
 

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`#`
`11`	`11`	`###############################################################################`
`12`	`12`
	`13`	`+coefficient_ring_type(T::Type{<:FreeAssociativeAlgebra}) = base_ring_type(T)`
`13`	`14`	`coefficient_ring(R::FreeAssociativeAlgebra{T}) where T <: RingElement = base_ring(R)`
`14`	`15`
`15`	`16`	`function is_domain_type(::Type{S}) where {T <: RingElement, S <: FreeAssociativeAlgebraElem{T}}`