Pass int tests with DynamicPolynomials

Author: blegat

src/monomial.jl

@@ -122,6 +122,9 @@ 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)

src/operators.jl

@@ -74,6 +74,8 @@ _multconstant(α, f, p::AbstractPolynomialLike) = _multconstant(α, f, polynomia
 multconstant(α, p::AbstractPolynomialLike) = _multconstant(α, β -> α*β, p)
 multconstant(p::AbstractPolynomialLike, α) = _multconstant(α, β -> β*α, p)
 
+MA.mutable_operate_to!(output::AbstractMonomial, ::typeof(*), m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponents_to!(output, +, m1, m2)
+MA.mutable_operate!(::typeof(*), m1::AbstractMonomial, m2::AbstractMonomialLike) = mapexponents!(+, m1, m2)
 Base.:*(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponents(+, m1, m2)
 #Base.:*(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = *(monomial(m1), monomial(m2))
 
@@ -140,3 +142,19 @@ Base.vec(vars::Tuple{Vararg{AbstractVariable}}) = [vars...]
 
 # https://github.com/JuliaLang/julia/pull/23332
 Base.:^(x::AbstractPolynomialLike, p::Integer) = Base.power_by_squaring(x, p)
+
+function MA.mutable_operate_to!(output::AbstractPolynomial, ::typeof(MA.add_mul), x, args::Vararg{Any, N}) where N
+    return MA.mutable_operate_to!(output, +, x, *(args...))
+end
+function MA.mutable_operate!(::typeof(MA.add_mul), x, args::Vararg{Any, N}) where N
+    return MA.mutable_operate!(+, x, *(args...))
+end
+MA.buffer_for(::typeof(MA.add_mul), ::Type{<:AbstractPolynomial}, args::Vararg{Any, N}) where {N} = MA.promote_operation(*, args...)
+function MA.mutable_buffered_operate_to!(buffer::AbstractPolynomial, output::AbstractPolynomial, ::typeof(MA.add_mul), x, args::Vararg{Any, N}) where N
+    product = MA.operate_to!(buffer, *, args...)
+    return MA.mutable_operate_to!(output, +, x, product)
+end
+function MA.mutable_buffered_operate!(buffer::AbstractPolynomial, ::typeof(MA.add_mul), x, args::Vararg{Any, N}) where N
+    product = MA.operate_to!(buffer, *, args...)
+    return MA.mutable_operate!(+, x, product)
+end

test/commutativetests.jl

@@ -1,3 +1,5 @@
+include("mutable_arithmetics.jl")
+
 include("zip.jl")
 include("variable.jl")
 include("monomial.jl")

test/mutable_arithmetics.jl

@@ -0,0 +1,30 @@
+import MutableArithmetics
+const MA = MutableArithmetics
+
+@testset "MutableArithmetics with $T" for T in [BigInt]
+    Mod.@polyvar x y
+#    @testset "Int" begin
+        MA.Test.int_test(termtype(x, T), exclude = ["int_add", "int_add_mul", "int_zero"])
+        MA.Test.int_test(polynomialtype(x, T))
+#    end
+#    a = T(2) * x^2 + T(3) * x * y + T(4) * y
+#    b = T(4) * y^2 - T(1) * x * y + T(4) * x
+#    c = T(1) * x^2 + T(3) * x - T(4)
+#    d = T(5) * x^2 * y - T(3) * x + T(4) * y
+#    @testset "Scalar" begin
+#        MA.Test.scalar_test(a)
+#    end
+#    @testset "Quadratic" begin
+#        MA.Test.quadratic_test(a, b, c, d)
+#    end
+#    @testset "Sparse" begin
+#        MA.Test.sparse_test(a, b, T[a b c; b c a; a b a])
+#    end
+#    @testset "Vector" begin
+#        MA.Test.array_test(T[a, b, c])
+#    end
+#    @testset "Matrix" begin
+#        MA.Test.array_test(T[a b; c d])
+#        MA.Test.array_test(T[a b c; b c a; a b a])
+#    end
+end