Add a term method with coefficient and monomial (#149)

* Add a term method with coefficient and monomial

* Fixes

* Update DynamicPolynomials and TypedPolynomials lower bounds

Author: blegat

Project.toml

@@ -11,9 +11,9 @@ MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0"
 
 [compat]
 DataStructures = "0.17.7, 0.18"
-DynamicPolynomials = "0.3.12"
+DynamicPolynomials = "0.3.16"
 MutableArithmetics = "0.2"
-TypedPolynomials = "0.2.8"
+TypedPolynomials = "0.2.9"
 julia = "1"
 
 [extras]

src/operators.jl

@@ -208,8 +208,8 @@ Base.isapprox(α, p::APL; kwargs...) = isapprox(promote(p, α)...; kwargs...)
 # through the MA API without modifying `p`. We should either copy the monomial
 # here or implement a `MA.operate(-, p)` that copies it. We choose the first
 # option.
-Base.:-(m::AbstractMonomialLike) = (-1) * MA.copy_if_mutable(m)
-Base.:-(t::AbstractTermLike) = MA.operate(-, coefficient(t)) * MA.copy_if_mutable(monomial(t))
+Base.:-(m::AbstractMonomialLike) = _term(-1, MA.copy_if_mutable(m))
+Base.:-(t::AbstractTermLike) = _term(MA.operate(-, coefficient(t)), monomial(t))
 Base.:-(p::APL) = polynomial!((-).(terms(p)))
 Base.:+(p::Union{APL, RationalPoly}) = p
 Base.:*(p::Union{APL, RationalPoly}) = p
@@ -271,9 +271,9 @@ MA.mutable_operate!(::typeof(*), m1::AbstractMonomial, m2::AbstractMonomialLike)
 Base.:*(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponents(+, m1, m2)
 #Base.:*(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = *(monomial(m1), monomial(m2))
 
-Base.:*(m::AbstractMonomialLike, t::AbstractTermLike) = coefficient(t) * (m * monomial(t))
-Base.:*(t::AbstractTermLike, m::AbstractMonomialLike) = coefficient(t) * (monomial(t) * m)
-Base.:*(t1::AbstractTermLike, t2::AbstractTermLike) = (coefficient(t1) * coefficient(t2)) * (monomial(t1) * monomial(t2))
+Base.:*(m::AbstractMonomialLike, t::AbstractTermLike) = term(coefficient(t), m * monomial(t))
+Base.:*(t::AbstractTermLike, m::AbstractMonomialLike) = term(coefficient(t), monomial(t) * m)
+Base.:*(t1::AbstractTermLike, t2::AbstractTermLike) = term(coefficient(t1) * coefficient(t2), monomial(t1) * monomial(t2))
 
 Base.:*(t::AbstractTermLike, p::APL) = polynomial!(map(te -> t * te, terms(p)))
 Base.:*(p::APL, t::AbstractTermLike) = polynomial!(map(te -> te * t, terms(p)))
@@ -290,6 +290,9 @@ function _polynomial_2terms(t1::TT, t2::TT, ::Type{T}) where {TT<:AbstractTerm,
         polynomial(termtype(TT, T)[t1, t2], SortedUniqState())
     end
 end
+
+_term(α, mono) = term(α, MA.copy_if_mutable(mono))
+
 for op in [:+, :-]
     @eval begin
         Base.$op(t1::AbstractTermLike, t2::AbstractTermLike) = $op(term(t1), term(t2))
@@ -299,7 +302,7 @@ for op in [:+, :-]
             # t1 > t2 would compare the coefficient in case the monomials are equal
             # and it will throw a MethodError in case the coefficients are not comparable
             if monomial(t1) == monomial(t2)
-                polynomial($op(coefficient(t1), coefficient(t2)) * monomial(t1), S)
+                polynomial(_term($op(coefficient(t1), coefficient(t2)), monomial(t1)), S)
             elseif monomial(t1) > monomial(t2)
                 ts = _polynomial_2terms(t1, $op(t2), S)
             else
@@ -323,13 +326,13 @@ end
 
 LinearAlgebra.adjoint(v::AbstractVariable) = v
 LinearAlgebra.adjoint(m::AbstractMonomial) = m
-LinearAlgebra.adjoint(t::AbstractTerm) = LinearAlgebra.adjoint(coefficient(t)) * monomial(t)
+LinearAlgebra.adjoint(t::AbstractTerm) = _term(LinearAlgebra.adjoint(coefficient(t)), monomial(t))
 LinearAlgebra.adjoint(p::AbstractPolynomialLike) = polynomial(map(LinearAlgebra.adjoint, terms(p)))
 LinearAlgebra.adjoint(r::RationalPoly) = adjoint(numerator(r)) / adjoint(denominator(r))
 
 LinearAlgebra.transpose(v::AbstractVariable) = v
 LinearAlgebra.transpose(m::AbstractMonomial) = m
-LinearAlgebra.transpose(t::AbstractTerm) = LinearAlgebra.transpose(coefficient(t)) * monomial(t)
+LinearAlgebra.transpose(t::AbstractTerm) = _term(LinearAlgebra.transpose(coefficient(t)), monomial(t))
 LinearAlgebra.transpose(p::AbstractPolynomialLike) = polynomial(map(LinearAlgebra.transpose, terms(p)))
 LinearAlgebra.transpose(r::RationalPoly) = transpose(numerator(r)) / transpose(denominator(r))
 

src/term.jl

@@ -1,13 +1,28 @@
 export constantterm, term, termtype, zeroterm, coefficient, monomial
 
 """
+    term(coef, mono::AbstractMonomialLike)
+
+Returns a term with coefficient `coef` and monomial `mono`. There are two key
+difference between this and `coef * mono`:
+
+* `term(coef, mono)` does not copy `coef` and `mono` so modifying this term
+  with MutableArithmetics may modifying the input of this function.
+  To avoid this, call `term(MA.copy_if_mutable(coef), MA.copy_if_mutable(mono))`
+  where `MA = MutableArithmetics`.
+* Suppose that `coef = (x + 1)` and `mono = x^2`, `coef * mono` gives the polynomial
+  with integer coefficients `x^3 + x^2` which `term(x + 1, x^2)` gives a term
+  with polynomial coefficient `x + 1`.
+
     term(p::AbstractPolynomialLike)
 
 Converts the polynomial `p` to a term.
 When applied on a polynomial, it throws an `InexactError` if it has more than one term.
 When applied to a term, it is the identity and does not copy it.
 When applied to a monomial, it create a term of type `AbstractTerm{Int}`.
 """
+function term end
+term(coef, var::AbstractVariable) = term(coef, monomial(var))
 term(p::APL) = convert(termtype(p), p)
 
 """