Add test for variables for subs of zero power (#268)

* Add test for variables for subs of zero power

* checkout

* Update

* Stop checkout

* Fix format

* Fixes

* Fix format

* Fixes

Author: blegat

src/substitution.jl

@@ -41,23 +41,7 @@ is equivalent to:
     subs(polynomial, (x=>1, y=>2))
 """
 function substitute(st::_AST, p::_APL, s::AbstractMultiSubstitution)
-    return substitute(st, p, pair_zip(_monomial_vector_to_variable_tuple(s)))
-end
-
-# Evaluate the stream
-# If I do s2..., then
-# subs(x, x=>x+y, y=>2) would call substitute(Subs(), x+y, y=>2)
-# subs(x, x=>1, y=>2) would call substitute(Subs(), 1, y=>2)
-# so it would force use to also define
-# sustitute(::_AST, ..., ::AbstractSubstitution...) for Any, _APL and RationalPoly.
-#substitute(st::_AST, p::_APL, s1::AbstractSubstitution, s2::AbstractSubstitution...) = substitute(st, substitute(st, p, s1), s2...)
-function substitute(
-    st::_AST,
-    p::_APL,
-    s1::AbstractSubstitution,
-    s2::AbstractSubstitution...,
-)
-    return substitute(st, substitute(st, p, s1), s2)
+    return substitute(st, p, _flatten_subs(s))
 end
 
 ## Variables
@@ -82,35 +66,70 @@ function powersubstitute(
     return powersubstitute(st, s, p) * powersubstitute(st, s, p2...)
 end
 
-function _promote_subs(S, T, s::Substitution)
-    # `T` is a constant
-    return T
+function _promote_subs(
+    S,
+    ::Type{V},
+    s::Substitution,
+) where {V<:AbstractVariable}
+    return MA.promote_operation(substitute, S, V, typeof(s))
 end
 
-function _promote_subs(S, T::Type{<:Union{RationalPoly,_APL}}, s::Substitution)
-    return MA.promote_operation(substitute, S, T, typeof(s))
+function _flatten_subs(s::AbstractMultiSubstitution)
+    return pair_zip(_monomial_vector_to_variable_tuple(s))
 end
 
-function _promote_subs(S, T, s::AbstractMultiSubstitution)
-    return _promote_subs(
-        S,
-        T,
-        pair_zip(_monomial_vector_to_variable_tuple(s))...,
-    )
+function _flatten_subs(s::Substitution)
+    return (s,)
 end
 
-function _promote_subs(
-    S,
-    T,
-    head::AbstractSubstitution,
+# Turn a tuple of `AbstractSubstitution` into a `Tuple` if `Substitution`
+function _flatten_subs(
+    s::AbstractSubstitution,
     tail::Vararg{AbstractSubstitution,N},
 ) where {N}
-    return _promote_subs(S, _promote_subs(S, T, head), tail...)
+    return (_flatten_subs(s)..., _flatten_subs(tail...)...)
+end
+
+function power_promote(
+    S,
+    ::Type{V},
+    s::Substitutions,
+) where {V<:AbstractVariable}
+    T = MA.promote_operation(substitute, S, V, typeof.(_flatten_subs(s...))...)
+    return MA.promote_operation(*, T, T)
+end
+
+function power_promote(
+    S,
+    ::Vector{V},
+    s::Substitutions,
+) where {V<:AbstractVariable}
+    return power_promote(S, V, s)
+end
+
+function power_promote(
+    S,
+    ::Tuple{V},
+    s::Substitutions,
+) where {V<:AbstractVariable}
+    return power_promote(S, V, s)
+end
+
+function power_promote(
+    S,
+    vars::Tuple{V,Vararg{AbstractVariable,N}},
+    s::Substitutions,
+) where {V<:AbstractVariable,N}
+    return MA.promote_operation(
+        *,
+        power_promote(S, V, s),
+        power_promote(S, Base.tail(vars), s),
+    )
 end
 
 function substitute(st::_AST, m::AbstractMonomial, s::Substitutions)
     if isconstant(m)
-        return one(_promote_subs(typeof(st), typeof(m), s...))
+        return one(power_promote(typeof(st), variables(m), s))
     else
         return powersubstitute(st, s, powers(m)...)
     end

test/substitution.jl

@@ -70,6 +70,13 @@ import MutableArithmetics as MA
     @test p(varst => valst) == 13
     @test p(varsv => valsv) == 13
 
+    @testset "Eval on constant monomial" begin
+        m = constant_monomial(prod(x))
+        mr = m(x => reverse(x))
+        @test isconstant(mr)
+        @test variables(mr) == x
+    end
+
     Mod.@polyvar x y
     @test subs([x^2 + y, x + y], x => y) == [y^2 + y, 2y]