Add _upgrade and _add_gens

Author: SoongNoonien

src/MPoly.jl

@@ -1367,6 +1367,40 @@ function _map(g::T, p::MPolyRingElem, Rx) where {T}
    return finish(M)
 end
 
+###############################################################################
+#
+#  Universal polynomial ring methods
+#
+###############################################################################
+
+@doc raw"""
+    _upgrade(p::MPolyRingElem{T}, R::MPolyRing{T}) where {T}
+
+Return an element of `R` which is obtained from `p` by mapping the $i$-th variable
+of `parent(p)` to the $i$-th variable of `R`.
+For this to work, `R` needs to have at least as many variables as `parent(p)`.
+"""
+function _upgrade(p::MPolyRingElem{T}, R::MPolyRing{T}) where {T}
+   n = nvars(R) - nvars(parent(p))
+   n < 0 && error("Too few variables")
+   ctx = MPolyBuildCtx(R)
+   v0 = zeros(Int, n)
+   for (c, v) in zip(coefficients(p), exponent_vectors(p))
+      push_term!(ctx, c, vcat(v, v0))
+   end
+   return finish(ctx)
+end
+
+@doc raw"""
+    _add_gens(R::MPolyRing, varnames::Vector{Symbol})
+
+Return a new uncached multivariate polynomial ring which has the same properties
+as `R` but `varnames` as additional generators.
+"""
+function _add_gens(R::MPolyRing, varnames::Vector{Symbol})
+   return polynomial_ring_only(base_ring(R), vcat(symbols(R), varnames); internal_ordering=internal_ordering(R), cached=false)
+end
+
 ###############################################################################
 #
 #  Factorization

src/generic/UnivPoly.jl

@@ -65,7 +65,7 @@ function set_exponent_vector!(p::UnivPoly, i::Int, exps::Vector{Int})
    S = parent(p)
    len = length(exps)
    if len != nvars(parent(data(p)))
-      p.p = upgrade(S, data(p))
+      p.p = AbstractAlgebra._upgrade(data(p), base_ring(S))
       if len < nvars(S)
          exps = vcat(exps, zeros(Int, nvars(S) - len))
       end
@@ -96,7 +96,7 @@ function setcoeff!(p::UnivPoly, exps::Vector{Int}, c::T) where T <: RingElement
    S = parent(p)
    len = length(exps)
    if len != nvars(parent(data(p)))
-      p.p = upgrade(S, data(p))
+      p.p = AbstractAlgebra._upgrade(data(p), base_ring(S))
       if len < nvars(S)
          exps = vcat(exps, zeros(Int, nvars(S) - len))
       end
@@ -256,19 +256,16 @@ function _ensure_variables(S::UniversalPolyRing, v::Vector{<:VarName})
       end
    end
    if !isempty(added_symbols)
-      new_symbols = vcat(current_symbols, added_symbols)
-      S.base_ring = AbstractAlgebra.polynomial_ring_only(coefficient_ring(S), new_symbols; internal_ordering=internal_ordering(S), cached=false)
+      S.base_ring = AbstractAlgebra.AbstractAlgebra._add_gens(base_ring(S), added_symbols)
    end
    return idx
 end
 
 function gen(S::UniversalPolyRing, s::VarName)
    i = findfirst(==(Symbol(s)), symbols(S))
    if i === nothing
-      new_symbols = copy(symbols(S))
-      push!(new_symbols, Symbol(s))
-      i = length(new_symbols)
-      S.base_ring = AbstractAlgebra.polynomial_ring_only(coefficient_ring(S), new_symbols; internal_ordering=internal_ordering(S), cached=false)
+      S.base_ring = AbstractAlgebra.AbstractAlgebra._add_gens(base_ring(S), [Symbol(s)])
+      i = length(symbols(S))
    end
    return @inbounds gen(S, i)
 end
@@ -639,10 +636,10 @@ function isless(a::UnivPoly{T}, b::UnivPoly{T}) where {T}
    s = data(a)
    t = data(b)
    if nvars(parent(s)) != num
-      s = upgrade(S, s)
+      s = AbstractAlgebra._upgrade(s, base_ring(S))
    end
    if nvars(parent(t)) != num
-      t = upgrade(S, t)
+      t = AbstractAlgebra._upgrade(t, base_ring(S))
    end
    return isless(s, t)
 end
@@ -690,7 +687,7 @@ function deflate(p::UnivPoly{T}, shift::Vector{Int}, defl::Vector{Int}) where {T
       return UnivPoly{T}(deflate(pp, shift, defl), S)
    end
    if vlen > num
-      pp = upgrade(S, pp)
+      pp = AbstractAlgebra._upgrade(pp, base_ring(S))
       num = nvars(parent(pp))
    end
    if vlen < num
@@ -714,7 +711,7 @@ function inflate(p::UnivPoly{T}, shift::Vector{Int}, defl::Vector{Int}) where {T
       return UnivPoly{T}(inflate(pp, shift, defl), S)
    end
    if vlen > num
-      pp = upgrade(S, pp)
+      pp = AbstractAlgebra._upgrade(pp, base_ring(S))
       num = nvars(parent(pp))
    end
    if vlen < num
@@ -1186,16 +1183,6 @@ end
 #
 ###############################################################################
 
-function upgrade(S::UniversalPolyRing{T}, pp::MPolyRingElem{T}) where {T}
-   n = nvars(S) - nvars(parent(pp))
-   ctx = MPolyBuildCtx(base_ring(S))
-   v0 = zeros(Int, n)
-   for (c, v) in zip(coefficients(pp), exponent_vectors(pp))
-      push_term!(ctx, c, vcat(v, v0))
-   end
-   return finish(ctx)
-end
-
 function (a::UniversalPolyRing{T})(b::RingElement) where {T <: RingElement}
    return a(coefficient_ring(a)(b))
 end
@@ -1216,7 +1203,7 @@ function (S::UniversalPolyRing{T})(p::UnivPoly{T}) where {T <: RingElement}
    parent(p) !== S && error("Unable to coerce")
    n = nvars(S) - nvars(parent(data(p)))
    if n != 0
-      p = UnivPoly{T}(upgrade(S, data(p)), S)
+      p = UnivPoly{T}(AbstractAlgebra._upgrade(data(p), base_ring(S)), S)
    end
    return p
 end