Fallback on conversion

Author: blegat

src/conversion.jl

@@ -9,6 +9,43 @@ 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(::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 +61,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/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)

src/variable.jl

@@ -21,28 +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))
+variable(t::APL) = convert(variable_union_type(t), t)
 
 _errormono2var() = error("Monomial cannot be converted to a variable")
 _mono2var() = _errormono2var()

test/monomial.jl

@@ -25,9 +25,9 @@ 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
@@ -46,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

@@ -47,7 +47,7 @@
     @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