Merge pull request #124 from JuliaAlgebra/bl/mutable_arithmetics

Implement MutableArithmetics

Author: blegat

.travis.yml

@@ -5,6 +5,8 @@ os:
 julia:
   - 1.0
   - 1.1
+  - 1.2
+  - 1.3
   - nightly
 
 matrix:

Project.toml

@@ -5,16 +5,20 @@ repo = "https://github.com/JuliaAlgebra/MultivariatePolynomials.jl"
 version = "0.3.2"
 
 [deps]
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0"
 
 [compat]
+DataStructures = "0.17"
+MutableArithmetics = "0.1.1"
 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"]

appveyor.yml

@@ -1,6 +1,9 @@
 environment:
   matrix:
-  - julia_version: 0.7
+  - julia_version: 1.0
+  - julia_version: 1.1
+  - julia_version: 1.2
+  - julia_version: 1.3
   - julia_version: latest
 
 platform:

src/MultivariatePolynomials.jl

@@ -2,6 +2,11 @@ module MultivariatePolynomials
 
 import LinearAlgebra
 
+import DataStructures
+
+import MutableArithmetics
+const MA = MutableArithmetics
+
 export AbstractPolynomialLike, AbstractTermLike, AbstractMonomialLike
 """
     AbstractPolynomialLike{T}
@@ -10,13 +15,15 @@ Abstract type for a value that can act like a polynomial. For instance, an
 `AbstractTerm{T}` is an `AbstractPolynomialLike{T}` since it can act as a
 polynomial of only one term.
 """
-abstract type AbstractPolynomialLike{T} end
+abstract type AbstractPolynomialLike{T} <: MA.AbstractMutable end
+
 """
     AbstractTermLike{T}
 
 Abstract type for a value that can act like a term. For instance, an `AbstractMonomial` is an `AbstractTermLike{Int}` since it can act as a term with coefficient `1`.
 """
 abstract type AbstractTermLike{T} <: AbstractPolynomialLike{T} end
+
 """
     AbstractMonomialLike
 

src/conversion.jl

@@ -2,13 +2,14 @@ export variable
 
 function convertconstant end
 Base.convert(::Type{P}, α) where P<:APL = convertconstant(P, α)
-function Base.convert(::Type{P}, p::P) where P<:AbstractPolynomial
+function Base.convert(::Type{P}, p::P) where {T, P<:AbstractPolynomial{T}}
     return p
 end
 function Base.convert(::Type{P}, p::APL) where {T, P<:AbstractPolynomial{T}}
     return convert(P, polynomial(p, T))
 end
 
+MA.scaling(p::AbstractPolynomialLike{T}) where {T} = convert(T, p)
 Base.convert(::Type{Any}, p::APL) = p
 # Conversion polynomial -> scalar
 function Base.convert(S::Type{<:Union{Number, T}}, p::APL{T}) where T

src/differentiation.jl

@@ -37,7 +37,7 @@ differentiate(α::T, v::AbstractVariable) where T = zero(T)
 differentiate(v1::AbstractVariable, v2::AbstractVariable) = v1 == v2 ? 1 : 0
 differentiate(t::AbstractTermLike, v::AbstractVariable) = coefficient(t) * differentiate(monomial(t), v)
 # The polynomial function will take care of removing the zeros
-differentiate(p::APL, v::AbstractVariable) = polynomial(differentiate.(terms(p), v), SortedState())
+differentiate(p::APL, v::AbstractVariable) = polynomial!(differentiate.(terms(p), v), SortedState())
 differentiate(p::RationalPoly, v::AbstractVariable) = (differentiate(p.num, v) * p.den - p.num * differentiate(p.den, v)) / p.den^2
 
 const ARPL = Union{APL, RationalPoly}

src/monomial.jl

@@ -122,8 +122,12 @@ The multiplication `m1 * m2` is equivalent to `mapexponents(+, m1, m2)`, the uns
 """
 mapexponents(f, m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponents(f, monomial(m1), monomial(m2))
 
+function mapexponents_to! end
+function mapexponents! end
+
 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.