Update for MP renamings (#128)

* Update for MP renamings

* update ci

* Rename file monovec

* MP#master

Author: blegat

.github/workflows/ci.yml

@@ -27,7 +27,7 @@ jobs:
             os: ubuntu-latest
             arch: x64
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: julia-actions/setup-julia@v1
         with:
           version: ${{ matrix.version }}

src/DynamicPolynomials.jl

@@ -17,31 +17,31 @@ const DMonomialLike{C} = Union{Monomial{C}, PolyVar{C}}
 MA.mutability(::Type{<:Monomial}) = MA.IsMutable()
 include("term.jl")
 MA.mutability(::Type{Term{C, T}}) where {C, T} = MA.mutability(T)
-include("monovec.jl")
+include("monomial_vector.jl")
 include("poly.jl")
 MA.mutability(::Type{<:Polynomial}) = MA.IsMutable()
 const TermPoly{C, T} = Union{Term{C, T}, Polynomial{C, T}}
 const PolyType{C} = Union{Polynomial{C}, Term{C}, Monomial{C}, PolyVar{C}}
 MP.variable_union_type(::Union{PolyType{C}, Type{<:PolyType{C}}}) where {C} = PolyVar{C}
-MP.constantmonomial(::Type{<:PolyType{C}}) where {C} = Monomial{C}()
-MP.constantmonomial(p::PolyType) = Monomial(_vars(p), zeros(Int, nvariables(p)))
-MP.monomialtype(::Type{<:PolyType{C}}) where C = Monomial{C}
-MP.monomialtype(::PolyType{C}) where C = Monomial{C}
-#function MP.constantmonomial(::Type{Monomial{C}}, vars=PolyVar{C}[]) where {C}
+MP.constant_monomial(::Type{<:PolyType{C}}) where {C} = Monomial{C}()
+MP.constant_monomial(p::PolyType) = Monomial(_vars(p), zeros(Int, nvariables(p)))
+MP.monomial_type(::Type{<:PolyType{C}}) where C = Monomial{C}
+MP.monomial_type(::PolyType{C}) where C = Monomial{C}
+#function MP.constant_monomial(::Type{Monomial{C}}, vars=PolyVar{C}[]) where {C}
 #    return Monomial{C}(vars, zeros(Int, length(vars)))
 #end
-MP.termtype(::Union{TermPoly{C, T}, Type{<:TermPoly{C, T}}}) where {C, T} = Term{C, T}
-MP.termtype(::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{T}) where {C, T} = Term{C, T}
-MP.termtype(::Type{Polynomial{C}}) where {C} = Term{C}
-MP.polynomialtype(::Type{Term{C}}) where {C} = Polynomial{C}
-MP.polynomialtype(::Type{Term{C, T}}) where {T, C} = Polynomial{C, T}
-MP.polynomialtype(::Type{T}, ::Type{<:DMonomialLike{C}}) where {T, C} = Polynomial{C, T}
-MP.polynomialtype(::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{T}) where {C, T} = Polynomial{C, T}
+MP.term_type(::Union{TermPoly{C, T}, Type{<:TermPoly{C, T}}}) where {C, T} = Term{C, T}
+MP.term_type(::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{T}) where {C, T} = Term{C, T}
+MP.term_type(::Type{Polynomial{C}}) where {C} = Term{C}
+MP.polynomial_type(::Type{Term{C}}) where {C} = Polynomial{C}
+MP.polynomial_type(::Type{Term{C, T}}) where {T, C} = Polynomial{C, T}
+MP.polynomial_type(::Type{T}, ::Type{<:DMonomialLike{C}}) where {T, C} = Polynomial{C, T}
+MP.polynomial_type(::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{T}) where {C, T} = Polynomial{C, T}
 _vars(p::AbstractArray{<:PolyType}) = mergevars(_vars.(p))[1]
 MP.variables(p::Union{PolyType, MonomialVector, AbstractArray{<:PolyType}}) = _vars(p) # tuple(_vars(p))
 MP.nvariables(p::Union{PolyType, MonomialVector, AbstractArray{<:PolyType}}) = length(_vars(p))
-MP.similarvariable(p::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{Val{V}}) where {C, V} = PolyVar{C}(string(V))
-MP.similarvariable(p::Union{PolyType{C}, Type{<:PolyType{C}}}, V::Symbol) where {C} = PolyVar{C}(string(V))
+MP.similar_variable(p::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{Val{V}}) where {C, V} = PolyVar{C}(string(V))
+MP.similar_variable(p::Union{PolyType{C}, Type{<:PolyType{C}}}, V::Symbol) where {C} = PolyVar{C}(string(V))
 
 include("promote.jl")
 

src/cmult.jl

@@ -123,7 +123,7 @@ function multdivmono(v::Vector{PolyVar{true}}, x::Monomial{true}, op, z)
     end
     return w, z_new
 end
-function MP.mapexponents_to!(output::Monomial{true}, f::Function, x::Monomial{true}, y::Monomial{true})
+function MP.map_exponents_to!(output::Monomial{true}, f::Function, x::Monomial{true}, y::Monomial{true})
     if x.vars == y.vars
         if output.vars != x.vars
             n = length(x.vars)
@@ -137,35 +137,35 @@ function MP.mapexponents_to!(output::Monomial{true}, f::Function, x::Monomial{tr
     end
     return output
 end
-function MP.mapexponents!(f::Function, x::Monomial{true}, y::Monomial{true})
+function MP.map_exponents!(f::Function, x::Monomial{true}, y::Monomial{true})
     if x.vars == y.vars
         _operate_exponents_to!(x.z, f, x.z, y.z)
     else
         _multdivmono!(x.z, x.vars, copy(x.vars), y, f, copy(x.z))
     end
     return x
 end
-function MP.mapexponents(f::Function, x::Monomial{true}, y::Monomial{true})
+function MP.map_exponents(f::Function, x::Monomial{true}, y::Monomial{true})
     w, z = multdivmono(x.vars, y, f, x.z)
     return Monomial{true}(w, z)
 end
-function MP.mapexponents(f::Function, x::MonomialVector{true}, y::Monomial{true})
+function MP.map_exponents(f::Function, x::MonomialVector{true}, y::Monomial{true})
     w, Z = multdivmono(x.vars, y, f, x.Z)
     return MonomialVector{true}(w, Z)
 end
-function MP.mapexponents!(f::Function, x::MonomialVector{true}, y::Monomial{true})
+function MP.map_exponents!(f::Function, x::MonomialVector{true}, y::Monomial{true})
     _multdivmono!(x.Z, x.vars, copy(x.vars), y, f, copy.(x.Z))
     return x
 end
-function MP.mapexponents(f::Function, x::MonomialVector{true}, y::PolyVar{true})
-    return MP.mapexponents(f, x, MP.monomial(y))
+function MP.map_exponents(f::Function, x::MonomialVector{true}, y::PolyVar{true})
+    return MP.map_exponents(f, x, MP.monomial(y))
 end
-function MP.mapexponents!(f::Function, x::MonomialVector{true}, y::PolyVar{true})
-    return MP.mapexponents!(f, x, MP.monomial(y))
+function MP.map_exponents!(f::Function, x::MonomialVector{true}, y::PolyVar{true})
+    return MP.map_exponents!(f, x, MP.monomial(y))
 end
 function MA.operate!(::typeof(*), x::MonomialVector{true}, y::DMonomialLike{true})
-    return MP.mapexponents!(+, x, y)
+    return MP.map_exponents!(+, x, y)
 end
-Base.:(*)(y::MonomialVector{true}, x::DMonomialLike{true}) = MP.mapexponents(+, y, x)
+Base.:(*)(y::MonomialVector{true}, x::DMonomialLike{true}) = MP.map_exponents(+, y, x)
 Base.:(*)(x::DMonomialLike{true}, y::MonomialVector{true}) = y * x
 Base.:(*)(x::Monomial{true}, y::PolyVar{true}) = y * x

src/comp.jl

@@ -109,8 +109,8 @@ function (==)(x::MonomialVector{C}, y::MonomialVector{C}) where C
     end
     return true
 end
-(==)(mv::AbstractVector, x::MonomialVector) = monovec(mv) == x
-(==)(x::MonomialVector, mv::AbstractVector) = x == monovec(mv)
+(==)(mv::AbstractVector, x::MonomialVector) = monomial_vector(mv) == x
+(==)(x::MonomialVector, mv::AbstractVector) = x == monomial_vector(mv)
 
 # Comparison of Term
 function (==)(p::Polynomial{C}, q::Polynomial{C}) where {C}

src/diff.jl

@@ -1,7 +1,7 @@
 function MP.differentiate(m::Monomial{C}, x::PolyVar{C}) where C
     i = findfirst(isequal(x), _vars(m))
     if (i === nothing || i == 0) || m.z[i] == 0
-        zeroterm(m)
+        zero_term(m)
     else
         z = copy(m.z)
         z[i] -= 1

src/mono.jl

@@ -26,7 +26,7 @@ function Base.convert(::Type{Monomial{C}}, x::PolyVar{C}) where C
     return Monomial{C}([x], [1])
 end
 Monomial(x::PolyVar{C}) where C = convert(Monomial{C}, x)
-function MP.convertconstant(::Type{Monomial{C}}, α) where C
+function MP.convert_constant(::Type{Monomial{C}}, α) where C
     α == 1 || error("Cannot convert $α to a Monomial{$C} as it is not one")
     Monomial{C}(PolyVar{C}[], Int[])
 end

src/monovec.jl renamed to src/monomial_vector.jl

@@ -77,14 +77,14 @@ _vars(m::Union{Monomial, MonomialVector}) = m.vars
 # [x, y] -> Vector{PolyVar}
 # [x, x*y] -> Vector{Monomial}
 # [1, x] -> Vector{Term{Int}}
-const DMonoVecElemNonConstant{C} = Union{PolyVar{C}, Monomial{C}, Term{C}}
+const Dmonomial_vectorElemNonConstant{C} = Union{PolyVar{C}, Monomial{C}, Term{C}}
 # [1] -> Vector{Int}
-const DMonoVecElem{C} = Union{Int, DMonoVecElemNonConstant{C}}
-const DMonoVec{C} = AbstractVector{<:DMonoVecElem{C}}
+const Dmonomial_vectorElem{C} = Union{Int, Dmonomial_vectorElemNonConstant{C}}
+const Dmonomial_vector{C} = AbstractVector{<:Dmonomial_vectorElem{C}}
 
-MP.emptymonovec(vars::AbstractVector{PolyVar{C}}) where {C} = MonomialVector{C}(vars, Vector{Int}[])
-MP.emptymonovec(t::DMonoVecElemNonConstant) = emptymonovec(_vars(t))
-MP.emptymonovec(::Type{<:DMonoVecElemNonConstant{C}}) where {C} = MonomialVector{C}()
+MP.empty_monomial_vector(vars::AbstractVector{PolyVar{C}}) where {C} = MonomialVector{C}(vars, Vector{Int}[])
+MP.empty_monomial_vector(t::Dmonomial_vectorElemNonConstant) = empty_monomial_vector(_vars(t))
+MP.empty_monomial_vector(::Type{<:Dmonomial_vectorElemNonConstant{C}}) where {C} = MonomialVector{C}()
 
 function fillZfordeg!(Z, n, deg, ::Type{Val{true}}, filter::Function, ::Int)
     z = zeros(Int, n)
@@ -167,8 +167,8 @@ MP.monomials(vars::Tuple{Vararg{PolyVar}}, args...) = monomials([vars...], args.
 #end
 #MP.monomials(vars::TupOrVec{PV}, degs::Int, filter::Function = x->true) where {PV<:PolyVar} = monomials(vars, [degs], filter)
 
-function buildZvarsvec(::Type{PV}, X::DMonoVec) where {PV<:PolyVar}
-    varsvec = Vector{PV}[ (isa(x, DMonoVecElemNonConstant) ? _vars(x) : PolyVar[]) for x in X ]
+function buildZvarsvec(::Type{PV}, X::Dmonomial_vector) where {PV<:PolyVar}
+    varsvec = Vector{PV}[ (isa(x, Dmonomial_vectorElemNonConstant) ? _vars(x) : PolyVar[]) for x in X ]
     allvars, maps = mergevars(varsvec)
     nvars = length(allvars)
     Z = [zeros(Int, nvars) for i in 1:length(X)]
@@ -190,8 +190,8 @@ function buildZvarsvec(::Type{PV}, X::DMonoVec) where {PV<:PolyVar}
     allvars, Z
 end
 
-MP.sortmonovec(X::MonomialVector) = (1:length(X), X)
-function _sortmonovec(X::DMonoVec{C}) where {C}
+MP.sort_monomial_vector(X::MonomialVector) = (1:length(X), X)
+function _sort_monomial_vector(X::Dmonomial_vector{C}) where {C}
     allvars, Z = buildZvarsvec(PolyVar{C}, X)
     σ = sortperm(Z, lt=grlex)
     allvars, Z, σ
@@ -200,34 +200,34 @@ function _removedups!(Z::Vector{Vector{Int}}, σ::Vector{Int})
     dups = findall(i -> Z[σ[i]] == Z[σ[i-1]], 2:length(σ))
     deleteat!(σ, dups)
 end
-function MP.sortmonovec(X::DMonoVec{C}) where {C}
+function MP.sort_monomial_vector(X::Dmonomial_vector{C}) where {C}
     if isempty(X)
         Int[], MonomialVector{C}()
     else
-        allvars, Z, σ = _sortmonovec(X)
+        allvars, Z, σ = _sort_monomial_vector(X)
         _removedups!(Z, σ)
         σ, MonomialVector{C}(allvars, Z[σ])
     end
 end
 
-function MonomialVector{C}(X::DMonoVec{C}) where C
+function MonomialVector{C}(X::Dmonomial_vector{C}) where C
     allvars, Z = buildZvarsvec(PolyVar{C}, X)
     sort!(Z, lt=grlex)
     dups = findall(i -> Z[i] == Z[i-1], 2:length(Z))
     deleteat!(Z, dups)
     MonomialVector{C}(allvars, Z)
 end
 function MonomialVector(X)
-    monovectype(X)(X)
+    monomial_vector_type(X)(X)
 end
 
-MP.monovectype(X::Union{DMonoVecElemNonConstant{C}, Type{<:DMonoVecElemNonConstant{C}}, DMonoVec{C}, Type{<:DMonoVec{C}}}) where {C} = MonomialVector{C}
-function MP.monovec(X::DMonoVec)
+MP.monomial_vector_type(X::Union{Dmonomial_vectorElemNonConstant{C}, Type{<:Dmonomial_vectorElemNonConstant{C}}, Dmonomial_vector{C}, Type{<:Dmonomial_vector{C}}}) where {C} = MonomialVector{C}
+function MP.monomial_vector(X::Dmonomial_vector)
     MonomialVector(X)
 end
-MP.monovec(a, mv::MonomialVector) = (a, mv)
+MP.monomial_vector(a, mv::MonomialVector) = (a, mv)
 
-function MP.mergemonovec(ms::Vector{MonomialVector{C}}) where {C}
+function MP.merge_monomial_vectors(ms::Vector{MonomialVector{C}}) where {C}
     m = length(ms)
     I = ones(Int, length(ms))
     L = length.(ms)

src/mult.jl

@@ -38,7 +38,7 @@ include("ncmult.jl")
 MP.left_constant_mult(α, x::Monomial)   = MP.term(α, MA.mutable_copy(x))
 
 function zero_with_variables(::Type{Polynomial{C,T}}, vars::Vector{PolyVar{C}}) where{C, T}
-    Polynomial(T[], emptymonovec(vars))
+    Polynomial(T[], empty_monomial_vector(vars))
 end
 
 # I do not want to cast x to TermContainer because that would force the promotion of eltype(q) with Int
@@ -47,7 +47,7 @@ function Base.:(*)(x::DMonomialLike, p::Polynomial)
 end
 function Base.:(*)(x::DMonomialLike{false}, p::Polynomial)
     # Order may change, e.g. y * (x + y) = y^2 + yx
-    Polynomial(monovec(MA.mutable_copy(p.a), [x*m for m in p.x])...)
+    Polynomial(monomial_vector(MA.mutable_copy(p.a), [x*m for m in p.x])...)
 end
 
 function _term_poly_mult(t::Term{C, S}, p::Polynomial{C, T}, op::Function) where {C, S, T}
@@ -133,7 +133,7 @@ function MA.operate!(::typeof(*), p::Polynomial{C}, q::Polynomial{C}) where C
     if iszero(q)
         return MA.operate!(zero, p)
     elseif nterms(q) == 1
-        return MA.operate!(*, p, MP.leadingterm(q))
+        return MA.operate!(*, p, MP.leading_term(q))
     else
         return MA.operate_to!(p, *, p, q)
     end

src/poly.jl

@@ -34,15 +34,15 @@ MA.mutable_copy(p::Polynomial{C, T}) where {C, T} = Polynomial{C, T}(MA.mutable_
 Base.copy(p::Polynomial) = MA.mutable_copy(p)
 Base.zero(::Type{Polynomial{C, T}}) where {C, T} = Polynomial(T[], MonomialVector{C}())
 Base.one(::Type{Polynomial{C, T}}) where {C, T} = Polynomial([one(T)], MonomialVector{C}(PolyVar{C}[], [Int[]]))
-Base.zero(p::Polynomial{C, T}) where {C, T} = Polynomial(T[], emptymonovec(copy(_vars(p))))
+Base.zero(p::Polynomial{C, T}) where {C, T} = Polynomial(T[], empty_monomial_vector(copy(_vars(p))))
 Base.one(p::Polynomial{C, T}) where {C, T} = Polynomial([one(T)], MonomialVector(copy(_vars(p)), [zeros(Int, nvariables(p))]))
 
 Polynomial{C, T}(a::AbstractVector, x::MonomialVector) where {C, T} = Polynomial{C, T}(Vector{T}(a), x)
-Polynomial{C, T}(a::AbstractVector, X::DMonoVec) where {C, T} = Polynomial{C, T}(monovec(a, X)...)
+Polynomial{C, T}(a::AbstractVector, X::Dmonomial_vector) where {C, T} = Polynomial{C, T}(monomial_vector(a, X)...)
 Polynomial{C}(a::Vector{T}, x) where {C, T} = Polynomial{C, T}(a, x)
-Polynomial(af::Union{Function, Vector}, x::DMonoVec{C}) where {C} = Polynomial{C}(af, x)
+Polynomial(af::Union{Function, Vector}, x::Dmonomial_vector{C}) where {C} = Polynomial{C}(af, x)
 
-# TODO Remove with MP v0.2.8
+# This is called by the default implementation of `Base.oneunit`, still in Julia v1.8 at least
 Polynomial{C, T}(p::Polynomial{C, T}) where {C, T} = p
 
 Base.convert(::Type{Polynomial{C, T}}, p::Polynomial{C, T}) where {C, T} = p
@@ -72,7 +72,7 @@ function Polynomial{C, T}(f::Function, x::MonomialVector{C}) where {C, T}
     Polynomial{C, T}(a, x)
 end
 function Polynomial{C, T}(f::Function, x::AbstractVector) where {C, T}
-    σ, X = sortmonovec(x)
+    σ, X = sort_monomial_vector(x)
     a = T[f(i) for i in σ]
     if length(x) > length(X)
         rev = Dict(X[j] => j for j in eachindex(σ))
@@ -90,8 +90,8 @@ Polynomial{C}(f::Function, x) where {C} = Polynomial{C, Base.promote_op(f, Int)}
 #Base.convert(::Type{PolyType{C}}, p::TermContainer{C}) where {C} = p
 
 # needed to build [p Q; Q p] where p is a polynomial and Q is a matpolynomial in Julia v0.5
-#Base.convert(::Type{TermType{C}}, p::TermContainer{C}) where {C} = p
-#Base.convert(::Type{TermType{C, T}}, p::TermContainer{C, T}) where {C, T} = p
+#Base.convert(::Type{term_type{C}}, p::TermContainer{C}) where {C} = p
+#Base.convert(::Type{term_type{C, T}}, p::TermContainer{C, T}) where {C, T} = p
 
 Base.length(p::Polynomial) = length(p.a)
 Base.isempty(p::Polynomial) = isempty(p.a)
@@ -128,19 +128,19 @@ MP.extdegree(p::Polynomial) = extdegree(p.x)
 MP.mindegree(p::Polynomial) = mindegree(p.x)
 MP.maxdegree(p::Polynomial) = maxdegree(p.x)
 
-MP.leadingcoefficient(p::Polynomial{C, T}) where {C, T} = iszero(p) ? zero(T) : last(p.a)
-MP.leadingmonomial(p::Polynomial) = iszero(p) ? constantmonomial(p) : last(p.x)
-MP.leadingterm(p::Polynomial) = iszero(p) ? zeroterm(p) : last(terms(p))
+MP.leading_coefficient(p::Polynomial{C, T}) where {C, T} = iszero(p) ? zero(T) : last(p.a)
+MP.leading_monomial(p::Polynomial) = iszero(p) ? constant_monomial(p) : last(p.x)
+MP.leading_term(p::Polynomial) = iszero(p) ? zero_term(p) : last(terms(p))
 
-function MP.removeleadingterm(p::Polynomial)
+function MP.remove_leading_term(p::Polynomial)
     Polynomial(p.a[1:end-1], p.x[1:end-1])
 end
-function MA.operate!(::typeof(MP.removeleadingterm), p::Polynomial)
+function MA.operate!(::typeof(MP.remove_leading_term), p::Polynomial)
     pop!(p.a)
     pop!(p.x)
     return p
 end
-function MP.removemonomials(p::Polynomial, x::MonomialVector)
+function MP.remove_monomials(p::Polynomial, x::MonomialVector)
     # use the fact that monomials are sorted to do this O(n) instead of O(n^2)
     j = 1
     I = Int[]
@@ -154,7 +154,7 @@ function MP.removemonomials(p::Polynomial, x::MonomialVector)
     end
     Polynomial(p.a[I], p.x[I])
 end
-MP.removemonomials(p::Polynomial, x::Vector) = removemonomials(p, MonomialVector(x))
+MP.remove_monomials(p::Polynomial, x::Vector) = remove_monomials(p, MonomialVector(x))
 
 function _remove_zeros!(p::Polynomial)
     zeroidx = Int[]
@@ -201,8 +201,8 @@ function polynomialclean_to!(p::Polynomial{C, T}, vars::Vector{PolyVar{C}}, adup
     return p
 end
 
-MP.polynomial!(a::Vector, x::DMonoVec, ::MP.ListState) = Polynomial(a, x)
-MP.polynomial(a::AbstractVector, x::DMonoVec, s::MP.ListState) = MP.polynomial!(collect(a), MA.mutable_copy(x), s)
+MP.polynomial!(a::Vector, x::Dmonomial_vector, ::MP.ListState) = Polynomial(a, x)
+MP.polynomial(a::AbstractVector, x::Dmonomial_vector, s::MP.ListState) = MP.polynomial!(collect(a), MA.mutable_copy(x), s)
 
 #MP.polynomial(f::Function, x::AbstractVector) = Polynomial(f, x)
 #MP.polynomial(ts::AbstractVector{Term{C, T}}) where {C, T} = Polynomial(coefficient.(ts), monomial.(ts)) # FIXME invalid age range update
@@ -251,7 +251,7 @@ function MP.polynomial(Q::AbstractMatrix, mv::MonomialVector{C}, ::Type{T}) wher
                     end
                 end
             end
-            a, X = monovec(a, x)
+            a, X = monomial_vector(a, x)
             v = _vars(X)
             Z = X.Z
         end
@@ -277,22 +277,22 @@ function MA.operate!(::typeof(one), p::Polynomial{C, T}) where {C, T}
     return p
 end
 
-function MP.mapcoefficients(f::Function, p::Polynomial; nonzero = false)
+function MP.map_coefficients(f::Function, p::Polynomial; nonzero = false)
     return Polynomial(map(f, p.a), MA.mutable_copy(p.x))
 end
 
-function MP.mapcoefficients!(f::Function, p::Polynomial; nonzero = false)
+function MP.map_coefficients!(f::Function, p::Polynomial; nonzero = false)
     map!(f, p.a, p.a)
     if !nonzero
         _remove_zeros!(p)
     end
     return p
 end
 
-function MP.mapcoefficients_to!(output::Polynomial, f::Function, t::MP.AbstractTermLike; nonzero = false)
-    return MP.mapcoefficients_to!(output, f, polynomial(t); nonzero = nonzero)
+function MP.map_coefficients_to!(output::Polynomial, f::Function, t::MP.AbstractTermLike; nonzero = false)
+    return MP.map_coefficients_to!(output, f, polynomial(t); nonzero = nonzero)
 end
-function MP.mapcoefficients_to!(output::Polynomial, f::Function, p::Polynomial; nonzero = false)
+function MP.map_coefficients_to!(output::Polynomial, f::Function, p::Polynomial; nonzero = false)
     resize!(output.a, length(p.a))
     map!(f, output.a, p.a)
     Future.copy!(output.x.vars, p.x.vars)
@@ -307,11 +307,11 @@ function MP.mapcoefficients_to!(output::Polynomial, f::Function, p::Polynomial;
     return output
 end
 
-function MP.mapexponents(f::Function, p::Polynomial, m::DMonomialLike)
-    return Polynomial(MA.mutable_copy(p.a), MP.mapexponents(f, p.x, m))
+function MP.map_exponents(f::Function, p::Polynomial, m::DMonomialLike)
+    return Polynomial(MA.mutable_copy(p.a), MP.map_exponents(f, p.x, m))
 end
 
-function MP.mapexponents!(f::Function, p::Polynomial, m::DMonomialLike)
-    MP.mapexponents!(f, p.x, m)
+function MP.map_exponents!(f::Function, p::Polynomial, m::DMonomialLike)
+    MP.map_exponents!(f, p.x, m)
     return p
 end