Merge pull request #140 from JuliaAlgebra/bl/comparison_terms

Add comparison tests

Author: blegat

src/comparison.jl

@@ -40,6 +40,19 @@ eqconstant(t::AbstractTermLike, α) = _termeqconstant(t, α)
 eqconstant(α, p::APL) = polyeqterm(p, α)
 eqconstant(p::APL, α) = polyeqterm(p, α)
 
+function Base.:(==)(mono::AbstractMonomial, v::AbstractVariable)
+    return isone(degree(mono)) && variable(mono) == v
+end
+function Base.:(==)(v::AbstractVariable, mono::AbstractMonomial)
+    return isone(degree(mono)) && v == variable(mono)
+end
+function Base.:(==)(t::AbstractTerm, mono::AbstractMonomialLike)
+    return isone(coefficient(t)) && monomial(t) == mono
+end
+function Base.:(==)(mono::AbstractMonomialLike, t::AbstractTerm)
+    return isone(coefficient(t)) && mono == monomial(t)
+end
+
 function Base.:(==)(t1::AbstractTerm, t2::AbstractTerm)
     c1 = coefficient(t1)
     c2 = coefficient(t2)

src/conversion.jl

@@ -9,6 +9,53 @@ function Base.convert(::Type{P}, p::APL) where {T, P<:AbstractPolynomial{T}}
     return convert(P, polynomial(p, T))
 end
 
+function Base.convert(::Type{V}, mono::AbstractMonomial) where V <: AbstractVariable
+    variable = nothing
+    for v in variables(mono)
+        d = degree(mono, v)
+        if isone(d)
+            if variable === nothing
+                variable = v
+            else
+                throw(InexactError(:convert, V, mono))
+            end
+        elseif !iszero(d)
+            throw(InexactError(:convert, V, mono))
+        end
+    end
+    if variable === nothing
+        throw(InexactError(:convert, V, mono))
+    end
+    return variable
+end
+
+function Base.convert(::Type{M}, t::AbstractTerm) where M <: AbstractMonomialLike
+    if isone(coefficient(t))
+        return convert(M, monomial(t))
+    else
+        throw(InexactError(:convert, M, t))
+    end
+end
+function Base.convert(TT::Type{<:AbstractTerm{T}}, m::AbstractMonomialLike) where T
+    return convert(TT, one(T) * m)
+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
+    return t
+end
+
+function Base.convert(::Type{T}, p::AbstractPolynomial) where T <: AbstractTermLike
+    if iszero(nterms(p))
+        convert(T, zeroterm(p))
+    elseif isone(nterms(p))
+        convert(T, leadingterm(p))
+    else
+        throw(InexactError(:convert, T, p))
+    end
+end
+
 MA.scaling(p::AbstractPolynomialLike{T}) where {T} = convert(T, p)
 Base.convert(::Type{Any}, p::APL) = p
 # Conversion polynomial -> scalar
@@ -24,14 +71,4 @@ function Base.convert(S::Type{<:Union{Number, T}}, p::APL{T}) where T
     s
 end
 
-# Fix ambiguity caused by above conversions
-Base.convert(::Type{P}, p::APL) where P<:APL = P(p)
-
 Base.convert(::Type{PT}, p::PT) where {PT<:APL} = p
-function Base.convert(::Type{MT}, t::AbstractTerm) where {MT<:AbstractMonomial}
-    if isone(coefficient(t))
-        monomial(t)
-    else
-        error("Cannot convert a term with a coefficient that is not one into a monomial")
-    end
-end

src/monomial.jl

@@ -25,6 +25,7 @@ Note that the variables of `m` does not necessarily have nonzero degree.
 For instance, `variables([x^2*y, y*z][1])` is usually `(x, y, z)` since the two monomials have been promoted to a common type.
 """
 function variables end
+variables(t::AbstractTerm) = variables(monomial(t))
 
 """
     nvariables(p::AbstractPolynomialLike)
@@ -36,6 +37,7 @@ Returns the number of variables in `p`, i.e. `length(variables(p))`. It could be
 Calling `nvariables(x^2*y)` should return at least 2 and calling `nvariables(x)` should return at least 1.
 """
 nvariables(::Union{AbstractVariable, Type{<:AbstractVariable}}) = 1
+nvariables(p::APL) = length(variables(p))
 
 """
     exponents(t::AbstractTermLike)

src/promote.jl

@@ -15,6 +15,16 @@ 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}

src/term.jl

@@ -4,21 +4,11 @@ export constantterm, term, termtype, zeroterm, coefficient, monomial
     term(p::AbstractPolynomialLike)
 
 Converts the polynomial `p` to a term.
-When applied on a polynomial, it throws an error if it has more than one term.
+When applied on a polynomial, it throws an `InexactError` if it has more than one term.
 When applied to a term, it is the identity and does not copy it.
 When applied to a monomial, it create a term of type `AbstractTerm{Int}`.
 """
-function term(p::APL{T}) where T
-    if nterms(p) == 0
-        zeroterm(p)
-    elseif nterms(p) > 1
-        error("A polynomial is more than one term cannot be converted to a term.")
-    else
-        leadingterm(p)
-    end
-end
-term(t::AbstractTerm) = t
-term(m::AbstractMonomialLike) = 1 * m
+term(p::APL) = convert(termtype(p), p)
 
 """
     termtype(p::AbstractPolynomialLike)
@@ -61,6 +51,8 @@ Calling `coefficient` on ``4x^2y`` should return ``4``.
 Calling `coefficient(2x + 4y^2 + 3, y^2)` should return ``4``.
 Calling `coefficient(2x + 4y^2 + 3, x^2)` should return ``0``.
 """
+function coefficient end
+coefficient(t::AbstractTerm) = t.coefficient # by convention, the field should be `coefficient`
 coefficient(m::AbstractMonomialLike) = 1
 function coefficient(p::AbstractPolynomialLike{T}, m::AbstractMonomialLike) where T
     for t in terms(p)
@@ -126,6 +118,7 @@ Returns the monomial of the term `t`.
 Calling `monomial` on ``4x^2y`` should return ``x^2y``.
 """
 function monomial end
+monomial(t::AbstractTerm) = t.monomial # by convention, the field should be `monomial`.
 monomial(m::AbstractMonomial) = m
 
 """

src/variable.jl

@@ -21,49 +21,19 @@ function variable_union_type end
 """
     variable(p::AbstractPolynomialLike)
 
-Converts `p` to a variable. Throws an error if it is not possible.
+Converts `p` to a variable. Throws `InexactError` if it is not possible.
 
 ### Examples
 
 Calling `variable(x^2 + x - x^2)` should return the variable `x` and
 calling `variable(1.0y)` should return the variable `y` however calling
-`variable(2x)` or `variable(x + y)` should throw an error.
+`variable(2x)` or `variable(x + y)` should throw `InexactError`.
 
 ### Note
 
 This operation is not type stable for the TypedPolynomials implementation if `nvariables(p) > 1` but is type stable for DynamicPolynomials.
 """
-variable(m::AbstractMonomialLike) = _mono2var(powers(m)...)
-variable(v::AbstractVariable) = v
-function variable(t::AbstractTermLike)
-    if isone(coefficient(t))
-        variable(monomial(t))
-    else
-        error("A term with non-one coefficient cannot be converted into a variable")
-    end
-end
-variable(p::APL) = variable(term(p))
-
-_errormono2var() = error("Monomial cannot be converted to a variable")
-_mono2var() = _errormono2var()
-function _checknovar() end
-function _checknovar(ve, ves...)
-    if iszero(ve[2])
-        _checknovar(ves...)
-    else
-        _errormono2var()
-    end
-end
-function _mono2var(ve, ves...)
-    if iszero(ve[2])
-        _mono2var(ves...)
-    elseif isone(ve[2])
-        _checknovar(ves...)
-        ve[1]
-    else
-        _errormono2var()
-    end
-end
+variable(t::APL) = convert(variable_union_type(t), t)
 
 """
     name(v::AbstractVariable)::AbstractString

test/commutativetests.jl

@@ -1,4 +1,4 @@
-include("mutable_arithmetics.jl")
+#include("mutable_arithmetics.jl")
 
 include("zip.jl")
 include("variable.jl")

test/monomial.jl

@@ -25,11 +25,16 @@ const MP = MultivariatePolynomials
     @test degree(x * y[2]^2, y[1]) == 0
     @test degree(x * y[2]^2, y[2]) == 2
 
-    @test_throws ErrorException variable(x^2)
-    @test_throws ErrorException variable(x*y[1])
-    @test_throws ErrorException variable(constantmonomial(typeof(x)))
+    @test_throws InexactError variable(x^2)
+    @test_throws InexactError variable(x*y[1])
+    @test_throws InexactError variable(constantmonomial(typeof(x)))
+
+    @test x != constantmonomial(typeof(x))
+    @test constantmonomial(typeof(x)) != x
 
     m = x^2
+    @test x != m
+    @test m != x
     typetests(m)
     typetests([x^2, x^3])
     @test (@inferred polynomial(m)) isa AbstractPolynomial{Int}
@@ -41,7 +46,7 @@ const MP = MultivariatePolynomials
     @test variable(x^2 + x - x^2) isa AbstractVariable
     @test variable(1.0x) == x
     @test variable(1.0x) isa AbstractVariable
-    @test_throws ErrorException variable(x + 2x) == x
+    @test_throws InexactError variable(x + 2x) == x
 
     @test monic(x^2) == x^2
 

test/polynomial.jl

@@ -37,7 +37,7 @@ const MP = MultivariatePolynomials
     @test term(x + x^2 - x) == x^2
     @test term(x - x) isa AbstractTerm
     @test iszero(term(x - x))
-    @test_throws ErrorException term(x + x^2)
+    @test_throws InexactError term(x + x^2)
 
     Mod.@polyvar y
 

test/term.jl

@@ -51,7 +51,7 @@ Base.iszero(::CoefNotComparable) = false
     @test (@inferred polynomial(t, Float64)) isa AbstractPolynomial{Float64}
 
     @test_throws InexactError push!([1], 2x)
-    @test_throws ErrorException push!([x^2], 2x)
+    @test_throws InexactError push!([x^2], 2x)
 
     @testset "Effective variables" begin
         T = variable_union_type(x)