Implement MutableArithmetics

Author: blegat

Project.toml

@@ -6,15 +6,16 @@ version = "0.3.2"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0"
 
 [compat]
 julia = "1"
 
 [extras]
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 DynamicPolynomials = "7c1d4256-1411-5781-91ec-d7bc3513ac07"
-TypedPolynomials = "afbbf031-7a57-5f58-a1b9-b774a0fad08d"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+TypedPolynomials = "afbbf031-7a57-5f58-a1b9-b774a0fad08d"
 
 [targets]
 test = ["BenchmarkTools", "DynamicPolynomials", "Test", "TypedPolynomials"]

src/MultivariatePolynomials.jl

@@ -2,6 +2,9 @@ module MultivariatePolynomials
 
 import LinearAlgebra
 
+import MutableArithmetics
+const MA = MutableArithmetics
+
 export AbstractPolynomialLike, AbstractTermLike, AbstractMonomialLike
 """
     AbstractPolynomialLike{T}

src/monomial.jl

@@ -124,6 +124,7 @@ mapexponents(f, m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponen
 
 Base.one(::Type{TT}) where {TT<:AbstractMonomialLike} = constantmonomial(TT)
 Base.one(t::AbstractMonomialLike) = constantmonomial(t)
+MA.promote_operation(::typeof(one), MT::Type{<:AbstractMonomialLike}) = monomialtype(MT)
 # See https://github.com/JuliaAlgebra/MultivariatePolynomials.jl/issues/82
 # By default, Base do oneunit(v::VT) = VT(one(v)).
 # This tries to convert a monomial to a variable which does not work.

src/operators.jl

@@ -28,6 +28,9 @@ for (op, fun) in [(:+, :plusconstant), (:-, :minusconstant), (:*, :multconstant)
     @eval Base.$op(α, p::APL) = $fun(α, p)
 end
 
+MA.mutable_operate!(op::Union{typeof(+), typeof(-)}, p::AbstractPolynomial, q::AbstractPolynomial) = MA.mutable_operate_to!(p, op, p, q)
+MA.mutable_operate!(op::Union{typeof(+), typeof(-)}, p::AbstractPolynomial, q::AbstractPolynomialLike) = MA.mutable_operate!(op, p, polynomial(q))
+
 # Special case AbstractArrays of APLs
 # We add these instead of relying on the broadcasting API since the above method definitions are very wide.
 # In particular, there is support for Matrices as coefficents. In order to avoid issues like #104 we therefore

src/promote.jl

@@ -19,3 +19,25 @@ Base.promote_rule(::Type{RT}, ::Type{PT}) where {PT<:APL, RT<:RationalPoly} = pr
 #promote_rule(::Type{RationalPoly{C, S, T}}, ::Type{Term{C, U}}) where {C, S, T, U} = RationalPoly{C, promote_type(U, S), T}
 #promote_rule(::Type{Polynomial{C, U}}, ::Type{RationalPoly{C, S, T}}) where {C, S, T, U} = RationalPoly{C, promote_type(U, S), T}
 #promote_rule(::Type{RationalPoly{C, S, T}}, ::Type{Polynomial{C, U}}) where {C, S, T, U} = RationalPoly{C, promote_type(U, S), T}
+
+function MA.promote_operation(
+    op::Union{typeof(+), typeof(-)}, PT::Type{<:APL{S}},
+    ::Type{<:APL{T}}) where {S, T}
+
+    U = MA.promote_operation(op, S, T)
+    return polynomialtype(PT, U)
+end
+function MA.promote_operation(::typeof(*), MT::Type{<:AbstractMonomialLike},
+    ::Type{<:AbstractMonomialLike})
+    return monomialtype(MT)
+end
+function MA.promote_operation(::typeof(*), TT::Type{<:AbstractTermLike{S}},
+                              ::Type{<:AbstractTermLike{T}}) where {S, T}
+    U = MA.promote_operation(*, S, T)
+    return termtype(TT, U)
+end
+function MA.promote_operation(::typeof(*), PT::Type{<:APL{S}},
+                              ::Type{<:APL{T}}) where {S, T}
+    U = MA.promote_operation(MA.add_mul, S, T)
+    return polynomialtype(PT, U)
+end

src/term.jl

@@ -158,5 +158,8 @@ zeroterm(p::APL{T}) where {T} = constantterm(zero(T), p)
 
 Base.zero(::Type{TT}) where {T, TT<:AbstractTermLike{T}} = zero(polynomialtype(TT))
 Base.zero(t::AbstractTermLike{T}) where {T} = zero(polynomialtype(t))
+MA.promote_operation(::typeof(zero), PT::Type{<:AbstractTermLike}) = polynomialtype(PT)
 Base.one(::Type{TT}) where {T, TT<:AbstractTermLike{T}} = one(T) * constantmonomial(TT)
 Base.one(t::AbstractTermLike{T}) where {T} = one(T) * constantmonomial(t)
+MA.promote_operation(::typeof(one), TT::Type{<:AbstractTermLike}) = termtype(TT)
+MA.promote_operation(::typeof(one), PT::Type{<:AbstractPolynomialLike}) = polynomialtype(PT)