Merge pull request #142 from JuliaAlgebra/bl/promote

Simplify promotion

Author: blegat

src/conversion.jl

@@ -42,7 +42,10 @@ end
 function Base.convert(TT::Type{<:AbstractTerm{T}}, t::AbstractTerm) where T
     return convert(TT, convert(T, coefficient(t)) * monomial(t))
 end
-function Base.convert(::Type{T}, t::T) where T <: AbstractTerm
+
+# Base.convert(::Type{T}, t::T) where {T <: AbstractTerm} is ambiguous with above method.
+# we need the following:
+function Base.convert(::Type{TT}, t::TT) where {T, TT <: AbstractTerm{T}}
     return t
 end
 

src/hash.jl

@@ -1,26 +1,22 @@
-_hashpowers(u::UInt) = u
-function _hashpowers(u::UInt, power::Tuple, powers...)
-    if iszero(power[2])
-        _hashpowers(u, powers...)
-    else
-        _hashpowers(hash(power, u), powers...)
-    end
-end
 function Base.hash(m::AbstractMonomial, u::UInt)
     nnz = count(!iszero, exponents(m))
     if iszero(nnz)
         hash(1, u)
     elseif isone(nnz) && isone(degree(m))
+        # We want the has of `m` to match the hash of `variable(m)`
+        # so we ignore the exponent one.
         hash(variable(m), u)
     else
-        _hashpowers(u, powers(m)...)
+        reduce((u, power) -> iszero(power[2]) ? u : hash(power, u), powers(m), init=u)
     end
 end
 
 function Base.hash(t::AbstractTerm, u::UInt)
     if iszero(t)
         hash(0, u)
-    elseif coefficient(t) == 1
+    elseif isone(coefficient(t))
+        # We want the has of `t` to match the hash of `monomial(t)`
+        # so we ignore the coefficient one.
         hash(monomial(t), u)
     else
         hash(monomial(t), hash(coefficient(t), u))

src/promote.jl

@@ -1,10 +1,37 @@
-Base.promote_rule(::Type{PT}, ::Type{PS}) where {PT<:APL, PS<:APL} = promote_type(polynomialtype(PT), polynomialtype(PS))
-Base.promote_rule(::Type{PT}, ::Type{PT}) where {PT<:APL} = PT
+# MonomialLike
+Base.promote_rule(::Type{M}, ::Type{M}) where {M<:AbstractMonomialLike} = M
+function Base.promote_rule(M1::Type{<:AbstractMonomialLike},
+                           M2::Type{<:AbstractMonomialLike})
+    return promote_type(monomialtype(M1), monomialtype(M2))
+end
 
-promote_rule_constant(::Type{T}, ::Type{RationalPoly{NT, DT}}) where {T, NT, DT} = RationalPoly{promote_type(T, NT), promote_type(DT, termtype(DT))}
+# TermLike
+Base.promote_rule(::Type{T}, ::Type{T}) where {T<:AbstractTermLike} = T
+function Base.promote_rule(TS::Type{<:AbstractTermLike{S}}, TT::Type{<:AbstractTermLike{T}}) where {S, T}
+    U = promote_type(S, T)
+    M = promote_type(monomialtype(TS), monomialtype(TT))
+    return termtype(M, U)
+end
+function promote_rule_constant(::Type{S}, TT::Type{<:AbstractTermLike{T}}) where {S, T}
+    return termtype(TT, promote_type(S, T))
+end
+
+
+# PolynomialLike
+Base.promote_rule(::Type{PT}, ::Type{PT}) where {PT<:APL} = PT
+function Base.promote_rule(PS::Type{<:APL}, PT::Type{<:APL})
+    return polynomialtype(promote_type(termtype(PS), termtype(PT)))
+end
 
+function promote_rule_constant(::Type{S}, PT::Type{<:APL{T}}) where {S, T}
+    return polynomialtype(PT, promote_type(S, T))
+end
 Base.promote_rule(::Type{PT}, ::Type{T}) where {T, PT<:APL} = promote_rule_constant(T, PT)
 Base.promote_rule(::Type{T}, ::Type{PT}) where {T, PT<:APL} = promote_rule_constant(T, PT)
+
+# Rational
+promote_rule_constant(::Type{T}, ::Type{RationalPoly{NT, DT}}) where {T, NT, DT} = RationalPoly{promote_type(T, NT), promote_type(DT, termtype(DT))}
+
 Base.promote_rule(::Type{T}, ::Type{RT}) where {T, RT<:RationalPoly} = promote_rule_constant(T, RT)
 Base.promote_rule(::Type{RT}, ::Type{T}) where {T, RT<:RationalPoly} = promote_rule_constant(T, RT)
 
@@ -15,21 +42,7 @@ Base.promote_rule(::Type{RS}, ::Type{RT}) where {RS<:RationalPoly, RT<:RationalP
 Base.promote_rule(::Type{PT}, ::Type{RT}) where {PT<:APL, RT<:RationalPoly} = promote_rule_rational(PT, RT)
 Base.promote_rule(::Type{RT}, ::Type{PT}) where {PT<:APL, RT<:RationalPoly} = promote_rule_rational(PT, RT)
 
-# Promotion with Term
-function Base.promote_rule(ST::Type{<:AbstractTermLike{S}}, TT::Type{<:AbstractTerm{T}}) where {S, T}
-    U = promote_type(S, T)
-    UT = termtype(ST, U)
-    if UT != termtype(TT, U)
-        error("Cannot promote `$ST` and `$TT` to the same type.")
-    end
-    return UT
-end
-
-#promote_rule(::Type{Term{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{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}
-
+# MutableArithmetics
 function MA.promote_operation(
     op::Union{typeof(+), typeof(-)}, PT::Type{<:APL{S}},
     QT::Type{<:APL{T}}) where {S, T}