Define more mapcoefficient functions (#183)

* Define more mapcoefficient functions

* Clean up

* Fix

* Fix doc

* Fix

* Fix

Author: blegat

Project.toml

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

docs/src/types.md

@@ -68,7 +68,9 @@ leadingmonomial
 removeleadingterm
 removemonomials
 monic
-mapcoefficientsnz
+mapcoefficients
+mapcoefficients!
+mapcoefficients_to!
 ```
 
 ## Rational Polynomial Function

src/operators.jl

@@ -65,9 +65,15 @@ Base.:/(A::AbstractArray, p::APL) = map(f -> f / p, A)
 
 constant_function(::typeof(+)) = plusconstant
 constant_function(::typeof(-)) = minusconstant
-MA.operate!(op::Union{typeof(+), typeof(-)}, p::APL, α) = MA.operate!(constant_function(op), p, α)
+constant_function(::typeof(*)) = multconstant
+MA.operate!(op::Union{typeof(+), typeof(-), typeof(*)}, p::APL, α) = MA.operate!(constant_function(op), p, α)
+
+MA.operate!(op::typeof(*), α, p::APL) = MA.operate!(multconstant, α, p)
+MA.operate!(op::typeof(*), p::APL, α) = MA.operate!(multconstant, p, α)
+MA.operate!(op::typeof(/), p::APL, α) = mapcoefficients!(Base.Fix2(op, α), p)
 MA.operate_to!(output::AbstractPolynomial, op::typeof(*), α, p::APL) = MA.operate_to!(output, multconstant, α, p)
 MA.operate_to!(output::AbstractPolynomial, op::typeof(*), p::APL, α) = MA.operate_to!(output, multconstant, p, α)
+MA.operate_to!(output::APL, op::typeof(/), p::APL, α) = mapcoefficients_to!(output, Base.Fix2(op, α), p)
 
 function polynomial_merge!(
     n1::Int, n2::Int, get1::Function, get2::Function,
@@ -250,8 +256,7 @@ _multconstant(α, f, p::AbstractPolynomialLike) = _multconstant(α, f, polynomia
 multconstant(α, p::AbstractPolynomialLike) = _multconstant(α, β -> α*β, p)
 multconstant(p::AbstractPolynomialLike, α) = _multconstant(α, β -> β*α, p)
 
-function mapcoefficientsnz_to! end
-
+# TODO delete once DynamicPolynomials stops using it
 function _multconstant_to!(output, α, f, p)
     if iszero(α)
         MA.operate!(zero, output)
@@ -260,10 +265,16 @@ function _multconstant_to!(output, α, f, p)
     end
 end
 function MA.operate_to!(output, ::typeof(multconstant), p::APL, α)
-    _multconstant_to!(output, α, β -> β*α, p)
+    return _multconstant_to!(output, α, β -> β*α, p)
 end
 function MA.operate_to!(output, ::typeof(multconstant), α, p::APL)
-    _multconstant_to!(output, α, β -> α*β, p)
+    return _multconstant_to!(output, α, β -> α*β, p)
+end
+function MA.operate!(::typeof(multconstant), p::APL, α)
+    return mapcoefficients!(Base.Fix2(*, α), p)
+end
+function MA.operate!(::typeof(multconstant), α, p::APL)
+    return mapcoefficients!(Base.Fix1(*, α), p)
 end
 
 MA.operate_to!(output::AbstractMonomial, ::typeof(*), m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponents_to!(output, +, m1, m2)

src/polynomial.jl

@@ -3,6 +3,7 @@ export coefficienttype, monomialtype
 export mindegree, maxdegree, extdegree, effective_variables
 export leadingterm, leadingcoefficient, leadingmonomial
 export removeleadingterm, removemonomials, monic
+export mapcoefficients, mapcoefficients!, mapcoefficients_to!
 
 LinearAlgebra.norm(p::AbstractPolynomialLike, r::Int=2) = LinearAlgebra.norm(coefficients(p), r)
 
@@ -389,22 +390,65 @@ function _divtoone(t::AbstractTermLike{T}, α::S) where {T, S}
     end
 end
 
+# TODO deprecate
+mapcoefficientsnz(f::Function, p::APL) = mapcoefficients(f, p, nonzero = true)
+mapcoefficientsnz_to!(output::APL, f::Function, p::APL) = mapcoefficients_to!(output, f, p, nonzero = true)
+
 """
-    mapcoefficientsnz(f::Function, p::AbstractPolynomialLike)
+    mapcoefficients(f::Function, p::AbstractPolynomialLike, nonzero = false)
+
+Returns a polynomial with the same monomials as `p` but each coefficient `α` is replaced by `f(α)`.
+The function may return zero in which case the term is dropped.
+If the function is known to never returns zero for a nonzero input, `nonzero`
+can be set to `true` to get a small speedup.
 
-Returns the polynomial obtained by applying `f` to each coefficients where `f` is a function such that `f(x)` is nonzero if `x` is nonzero.
+See also [`mapcoefficients!`](@ref) and [`mapcoefficients_to!`](@ref).
 
 ### Examples
 
-Calling `mapcoefficientsnz(α -> α^2, 2x*y + 3x + 1)` should return `4x*y + 9x + 1`.
+Calling `mapcoefficients(α -> mod(3α, 6), 2x*y + 3x + 1)` should return `3x + 3`.
 """
-function mapcoefficientsnz(f::Function, p::AbstractPolynomialLike)
+function mapcoefficients end
+function mapcoefficients(f::Function, p::AbstractPolynomialLike; nonzero = false) # TODO remove
     # Invariant: p has only nonzero coefficient
     # therefore f(α) will be nonzero for every coefficient α of p
     # hence we can use Uniq
-    polynomial!(mapcoefficientsnz.(f, terms(p)), SortedUniqState())
+    polynomial!(mapcoefficients.(f, terms(p)), nonzero ? SortedUniqState() : SortedState())
 end
-mapcoefficientsnz(f::Function, t::AbstractTermLike) = term(f(coefficient(t)), monomial(t))
+function mapcoefficients(f::Function, t::AbstractTermLike; nonzero = false)
+    return term(f(coefficient(t)), monomial(t))
+end
+
+"""
+    mapcoefficients!(f::Function, p::AbstractPolynomialLike, nonzero = false)
+
+Mutate `p` by replacing each coefficient `α` by `f(α)`.
+The function may return zero in which case the term is dropped.
+If the function is known to never returns zero for a nonzero input, `nonzero`
+can be set to `true` to get a small speedup.
+The function returns `p`, which is identically equal to the second argument.
+
+See also [`mapcoefficients`](@ref) and [`mapcoefficients_to!`](@ref).
+
+### Examples
+
+Let `p = 2x*y + 3x + 1`, after `mapcoefficients!(α -> mod(3α, 6), p)`, `p` is
+equal to `3x + 3`.
+"""
+function mapcoefficients! end
+
+"""
+    mapcoefficients_to!(output::AbstractPolynomialLike, f::Function, p::AbstractPolynomialLike, nonzero = false)
+
+Mutate `output` by replacing each coefficient `α` of `p` by `f(α)`.
+The function may return zero in which case the term is dropped.
+If the function is known to never returns zero for a nonzero input, `nonzero`
+can be set to `true` to get a small speedup.
+The function returns `output`, which is identically equal to the first argument.
+
+See also [`mapcoefficients!`](@ref) and [`mapcoefficients`](@ref).
+"""
+function mapcoefficients_to! end
 
 """
     deg_num_leading_terms(p::AbstractPolynomialLike, var)

test/polynomial.jl

@@ -1,5 +1,8 @@
+using Test
+using LinearAlgebra
 import MutableArithmetics
 const MA = MutableArithmetics
+using MultivariatePolynomials
 const MP = MultivariatePolynomials
 @testset "Polynomial" begin
     Mod.@polyvar x

test/utils.jl

@@ -1,3 +1,6 @@
+using Test
+using MultivariatePolynomials
+
 # Allocating size for allocating a `BigInt`.
 # Half size on 32-bit.
 const BIGINT_ALLOC = Sys.WORD_SIZE == 64 ? 48 : 24