Rename dense_poly_type to poly_type (#2202)

Co-authored-by: Lars Göttgens <lars.goettgens@gmail.com>

Author: JohnAAbbott

docs/src/poly_interface.md

@@ -136,7 +136,7 @@ polynomial ring. This is provided for uniformity with the multivariate interface
 there is more than one variable and hence an array of symbols.
 
 ```julia
-dense_poly_type(::Type{T}) where T <: RingElement
+poly_type(::Type{T}) where T <: RingElement
 ```
 
 Return the type of a polynomial whose coefficients have the given type. In our
@@ -150,7 +150,7 @@ polynomial_ring_only(R::Ring, s::Symbol; cached::Bool=true)
 ```
 
 The default implementation figures out the appropriate polynomial ring type via
-`dense_poly_type` and calls its constructor with `R, s, cached` as arguments.
+`poly_type` and calls its constructor with `R, s, cached` as arguments.
 In our example, this would be
 
 ```julia

src/Deprecations.jl

@@ -12,6 +12,10 @@
 # renamed in 0.45.1
 @alias FactoredFractionField factored_fraction_field
 
+#renamed in 0.47.4
+@alias dense_poly_type poly_type
+@alias dense_poly_ring_type poly_ring_type
+
 ###############################################################################
 #
 #   Deprecated bindings

src/MPoly.jl

@@ -24,7 +24,7 @@ coefficient_ring(R::MPolyRing) = base_ring(R)
 The type of multivariate polynomials with coefficients of type `T` respectively `elem_type(S)`.
 Falls back to `Generic.MPoly{T}`.
 
-See also [`mpoly_ring_type`](@ref), [`dense_poly_type`](@ref) and [`dense_poly_ring_type`](@ref).
+See also [`mpoly_ring_type`](@ref), [`poly_type`](@ref) and [`poly_ring_type`](@ref).
 
 # Examples
 ```jldoctest
@@ -55,7 +55,7 @@ mpoly_type(::Type{T}) where T = throw(ArgumentError("Type `$T` must be subtype o
 The type of multivariate polynomial rings with coefficients of type `T`
 respectively `elem_type(S)`. Implemented via [`mpoly_type`](@ref).
 
-See also [`dense_poly_type`](@ref) and [`dense_poly_ring_type`](@ref).
+See also [`poly_type`](@ref) and [`poly_ring_type`](@ref).
 
 # Examples
 ```jldoctest

src/NCPoly.jl

@@ -20,63 +20,63 @@ function is_exact_type(a::Type{T}) where {S <: NCRingElem, T <: NCPolyRingElem{S
 end
 
 @doc raw"""
-    dense_poly_type(::Type{T}) where T<:NCRingElement
-    dense_poly_type(::T) where T<:NCRingElement
-    dense_poly_type(::Type{S}) where S<:NCRing
-    dense_poly_type(::S) where S<:NCRing
+    poly_type(::Type{T}) where T<:NCRingElement
+    poly_type(::T) where T<:NCRingElement
+    poly_type(::Type{S}) where S<:NCRing
+    poly_type(::S) where S<:NCRing
 
 The type of univariate polynomials with coefficients of type `T` respectively `elem_type(S)`.
 Falls back to `Generic.NCPoly{T}` respectively `Generic.Poly{T}`.
 
-See also [`dense_poly_ring_type`](@ref), [`mpoly_type`](@ref) and [`mpoly_ring_type`](@ref).
+See also [`poly_ring_type`](@ref), [`mpoly_type`](@ref) and [`mpoly_ring_type`](@ref).
 
 # Examples
 ```jldoctest
-julia> dense_poly_type(AbstractAlgebra.ZZ(1))
+julia> poly_type(AbstractAlgebra.ZZ(1))
 AbstractAlgebra.Generic.Poly{BigInt}
 
-julia> dense_poly_type(elem_type(AbstractAlgebra.ZZ))
+julia> poly_type(elem_type(AbstractAlgebra.ZZ))
 AbstractAlgebra.Generic.Poly{BigInt}
 
-julia> dense_poly_type(AbstractAlgebra.ZZ)
+julia> poly_type(AbstractAlgebra.ZZ)
 AbstractAlgebra.Generic.Poly{BigInt}
 
-julia> dense_poly_type(typeof(AbstractAlgebra.ZZ))
+julia> poly_type(typeof(AbstractAlgebra.ZZ))
 AbstractAlgebra.Generic.Poly{BigInt}
 ```
 """
-dense_poly_type(::Type{T}) where T<:NCRingElement = Generic.NCPoly{T}
-dense_poly_type(::Type{S}) where S<:NCRing = dense_poly_type(elem_type(S))
-dense_poly_type(x) = dense_poly_type(typeof(x)) # to stop this method from eternally recursing on itself, we better add ...
-dense_poly_type(::Type{T}) where T = throw(ArgumentError("Type `$T` must be subtype of `NCRingElement`."))
+poly_type(::Type{T}) where T<:NCRingElement = Generic.NCPoly{T}
+poly_type(::Type{S}) where S<:NCRing = poly_type(elem_type(S))
+poly_type(x) = poly_type(typeof(x)) # to stop this method from eternally recursing on itself, we better add ...
+poly_type(::Type{T}) where T = throw(ArgumentError("Type `$T` must be subtype of `NCRingElement`."))
 
 @doc raw"""
-    dense_poly_ring_type(::Type{T}) where T<:NCRingElement
-    dense_poly_ring_type(::T) where T<:NCRingElement
-    dense_poly_ring_type(::Type{S}) where S<:NCRing
-    dense_poly_ring_type(::S) where S<:NCRing
+    poly_ring_type(::Type{T}) where T<:NCRingElement
+    poly_ring_type(::T) where T<:NCRingElement
+    poly_ring_type(::Type{S}) where S<:NCRing
+    poly_ring_type(::S) where S<:NCRing
 
 The type of univariate polynomial rings with coefficients of type `T` respectively
-`elem_type(S)`. Implemented via [`dense_poly_type`](@ref).
+`elem_type(S)`. Implemented via [`poly_type`](@ref).
 
 See also [`mpoly_type`](@ref) and [`mpoly_ring_type`](@ref).
 
 # Examples
 ```jldoctest
-julia> dense_poly_ring_type(AbstractAlgebra.ZZ(1))
+julia> poly_ring_type(AbstractAlgebra.ZZ(1))
 AbstractAlgebra.Generic.PolyRing{BigInt}
 
-julia> dense_poly_ring_type(elem_type(AbstractAlgebra.ZZ))
+julia> poly_ring_type(elem_type(AbstractAlgebra.ZZ))
 AbstractAlgebra.Generic.PolyRing{BigInt}
 
-julia> dense_poly_ring_type(AbstractAlgebra.ZZ)
+julia> poly_ring_type(AbstractAlgebra.ZZ)
 AbstractAlgebra.Generic.PolyRing{BigInt}
 
-julia> dense_poly_ring_type(typeof(AbstractAlgebra.ZZ))
+julia> poly_ring_type(typeof(AbstractAlgebra.ZZ))
 AbstractAlgebra.Generic.PolyRing{BigInt}
 ```
 """
-dense_poly_ring_type(x) = parent_type(dense_poly_type(x))
+poly_ring_type(x) = parent_type(poly_type(x))
 
 @doc raw"""
     var(a::NCPolyRing)
@@ -779,7 +779,7 @@ Like [`polynomial_ring(R::NCRing, s::Symbol)`](@ref) but return only the
 polynomial ring.
 """
 polynomial_ring_only(R::T, s::Symbol; cached::Bool=true) where T<:NCRing =
-   dense_poly_ring_type(T)(R, s, cached)
+   poly_ring_type(T)(R, s, cached)
 
 # Simplified constructor
 

src/Poly.jl

@@ -15,7 +15,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}
+poly_type(::Type{T}) where T<:RingElement = Generic.Poly{T}
 
 function is_domain_type(::Type{T}) where {S <: RingElement, T <: PolyRingElem{S}}
    return is_domain_type(S)

src/exports.jl

@@ -180,8 +180,6 @@ export degree
 export degrees
 export denest
 export dense_matrix_type
-export dense_poly_ring_type
-export dense_poly_type
 export derivative
 export det
 export det_popov
@@ -471,6 +469,8 @@ export pol_length
 export polcoeff
 export poly
 export poly_ring
+export poly_ring_type
+export poly_type
 export polynomial
 export polynomial_ring
 export polynomial_to_power_sums

src/generic/FunctionField.jl

@@ -526,7 +526,7 @@ parent_type(::Type{FunctionFieldElem{T}}) where T <: FieldElement = FunctionFiel
 elem_type(::Type{FunctionField{T}}) where T <: FieldElement = FunctionFieldElem{T}
 
 function base_ring_type(::Type{FunctionField{T}}) where T <: FieldElement
-   U = dense_poly_type(T)
+   U = poly_type(T)
    return RationalFunctionField{T, U}
 end
 
@@ -581,19 +581,19 @@ defining_polynomial(R::FunctionField) = R.pol
 modulus(R::FunctionField) = defining_polynomial(R)
 
 function power_precomp(R::FunctionField{T}, n::Int) where T <: FieldElement
-   return R.powers[n + 1]::Poly{dense_poly_type(T)}
+   return R.powers[n + 1]::Poly{poly_type(T)}
 end
 
 function power_precomp_den(R::FunctionField{T}, n::Int) where T <: FieldElement
-   return R.powers_den[n + 1]::dense_poly_type(T)
+   return R.powers_den[n + 1]::poly_type(T)
 end
 
 function trace_precomp(R::FunctionField{T}, n::Int) where T <: FieldElement
-   return R.traces[n + 1]::dense_poly_type(T)
+   return R.traces[n + 1]::poly_type(T)
 end
 
 function trace_precomp_den(R::FunctionField{T}) where T <: FieldElement
-   return R.traces_den::dense_poly_type(T)
+   return R.traces_den::poly_type(T)
 end
 
 @doc raw"""
@@ -610,13 +610,13 @@ interface.
 function Base.numerator(R::FunctionField{T},
                                canonicalise::Bool=true) where T <: FieldElement
    # only used for type assert, so no need to canonicalise
-   return R.num::Poly{dense_poly_type(T)}
+   return R.num::Poly{poly_type(T)}
 end                 
 
 function Base.denominator(R::FunctionField{T},
                                canonicalise::Bool=true) where T <: FieldElement
    # only used for type assert, so no need to canonicalise
-   return R.den::dense_poly_type(T)
+   return R.den::poly_type(T)
 end                 
 
 @doc raw"""
@@ -630,8 +630,8 @@ If `canonicalise` is set to `true` the fraction is first canonicalised.
 """
 function Base.numerator(a::FunctionFieldElem{T},
                                canonicalise::Bool=true) where T <: FieldElement
-   anum = a.num::Poly{dense_poly_type(T)}
-   aden = a.den::dense_poly_type(T)
+   anum = a.num::Poly{poly_type(T)}
+   aden = a.den::poly_type(T)
    if canonicalise
       u = canonical_unit(aden)
       return divexact(anum, u)
@@ -642,7 +642,7 @@ end
 
 function Base.denominator(a::FunctionFieldElem{T},
                                canonicalise::Bool=true) where T <: FieldElement
-   aden = a.den::dense_poly_type(T)
+   aden = a.den::poly_type(T)
    if canonicalise
       u = canonical_unit(aden)
       return divexact(aden, u)
@@ -1248,7 +1248,7 @@ promote_rule(::Type{FunctionFieldElem{T}}, ::Type{FunctionFieldElem{T}}) where T
 function promote_rule(::Type{FunctionFieldElem{T}}, ::Type{V}) where
       {T <: FieldElement, V <: RingElem}
    # The base ring element type of FunctionFieldElem{T} is RationalFunctionFieldElem{T, U}, not T
-   U = dense_poly_type(T)
+   U = poly_type(T)
    promote_rule(RationalFunctionFieldElem{T, U}, V) == RationalFunctionFieldElem{T, U} ? FunctionFieldElem{T} : Union{}
 end
 

src/generic/PolyRingHom.jl

@@ -71,7 +71,7 @@ end
 
 function temp_ring(f::PolyRingAnyMap{<:Any, <: Any, <: Map})
   if isdefined(f, :temp_ring)
-    return f.temp_ring::dense_poly_ring_type(codomain(_coefficient_map(f)))
+    return f.temp_ring::poly_ring_type(codomain(_coefficient_map(f)))
   end
 
   S, = polynomial_ring(codomain(_coefficient_map(f)), cached = false)

test/generic/NCPoly-test.jl

@@ -431,8 +431,8 @@ end
 
 @testset "Generic.NCPoly.exceptions" begin
    @test_throws MethodError polynomial_ring(Char, :x)
-   @test_throws Exception dense_poly_ring_type(Char)
-   @test_throws ArgumentError dense_poly_type(Char)
+   @test_throws Exception poly_ring_type(Char)
+   @test_throws ArgumentError poly_type(Char)
 end
 
 @testset "Generic.NCPoly.map_coefficients" begin

test/generic/Poly-test.jl

@@ -17,8 +17,8 @@
 # algos differ, and 7 can often stand in for 5/6 if the algorithm supports it.
 
 @testset "Generic.Poly.types" begin
-   @test dense_poly_type(BigInt) == Generic.Poly{BigInt}
-   @test dense_poly_type(Rational{BigInt}) == Generic.Poly{Rational{BigInt}}
+   @test poly_type(BigInt) == Generic.Poly{BigInt}
+   @test poly_type(Rational{BigInt}) == Generic.Poly{Rational{BigInt}}
 end
 
 @testset "Generic.Poly.constructors" begin