close issue #344 (#345)

Author: jverzani

src/polynomials/ChebyshevT.jl

@@ -77,7 +77,7 @@ function Base.convert(P::Type{<:Polynomial}, ch::ChebyshevT)
 end
 Base.convert(C::Type{<:ChebyshevT}, p::Polynomial) = p(variable(C))
 
-
+Base.promote_rule(::Type{P},::Type{Q}) where {T, X, P <: LaurentPolynomial{T,X}, S, Q <: ChebyshevT{S, X}} = LaurentPolynomial{promote_type(T, S), X}
 
 domain(::Type{<:ChebyshevT}) = Interval(-1, 1)
 function Base.one(::Type{P}) where {P<:ChebyshevT}

src/polynomials/LaurentPolynomial.jl

@@ -126,6 +126,7 @@ end
 # LaurentPolynomial is a wider collection than other standard basis polynomials.
 Base.promote_rule(::Type{P},::Type{Q}) where {T, X, P <: LaurentPolynomial{T,X}, S, Q <: StandardBasisPolynomial{S, X}} = LaurentPolynomial{promote_type(T, S), X}
 
+
 Base.promote_rule(::Type{Q},::Type{P}) where {T, X, P <: LaurentPolynomial{T,X}, S, Q <: StandardBasisPolynomial{S,X}} =
     LaurentPolynomial{promote_type(T, S),X}
 
@@ -145,10 +146,21 @@ function Base.convert(::Type{P}, p::LaurentPolynomial) where {P<:LaurentPolynomi
     LaurentPolynomial{S,Y}(p.coeffs, p.m[])
 end
 
-function Base.convert(::Type{P}, q::StandardBasisPolynomial{S}) where {T, P <:LaurentPolynomial{T},S}
-    v′ = _indeterminate(P)
-    X = v′ == nothing ? indeterminate(q) : v′
-    ⟒(P){T,X}([q[i] for i in 0:degree(q)], 0)
+# function Base.convert(::Type{P}, q::StandardBasisPolynomial{S}) where {T, P <:LaurentPolynomial{T},S}
+#     v′ = _indeterminate(P)
+#     X = v′ == nothing ? indeterminate(q) : v′
+#     ⟒(P){T,X}([q[i] for i in 0:degree(q)], 0)
+# end
+
+function Base.convert(::Type{P}, q::StandardBasisPolynomial{S}) where {P <:LaurentPolynomial,S}
+
+     T = _eltype(P, q)
+     X = indeterminate(P, q)
+     ⟒(P){T,X}([q[i] for i in 0:degree(q)], 0)
+ end
+
+function Base.convert(::Type{P}, q::AbstractPolynomial) where {P <:LaurentPolynomial}
+    convert(P, convert(Polynomial, q))
 end
 
 ##
@@ -162,6 +174,9 @@ function Base.inv(p::LaurentPolynomial{T, X}) where {T, X}
     LaurentPolynomial{eltype(cs), X}(cs, -m)
 end
 
+Base.numerator(p::LaurentPolynomial) = numerator(convert(RationalFunction, p))
+Base.denominator(p::LaurentPolynomial) = denominator(convert(RationalFunction, p))
+
 ##
 ## changes to common.jl mostly as the range in the type is different
 ##

src/rational-functions/common.jl

@@ -52,12 +52,33 @@ function Base.convert(::Type{PQ}, p::Number) where {PQ <: AbstractRationalFuncti
    rational_function(PQ, p * one(P), one(P))
 end
 
+function Base.convert(::Type{PQ}, q::LaurentPolynomial) where {PQ <: AbstractRationalFunction}
+    m = firstindex(q)
+    if m >= 0
+        p = convert(Polynomial, q)
+        return convert(PQ, p)
+    else
+        z = variable(q)
+        zᵐ = z^(-m)
+        p = convert(Polynomial, zᵐ * q)
+        return rational_function(PQ, p, convert(Polynomial, zᵐ))
+    end
+
+end
+
+
 function Base.convert(::Type{PQ}, p::P) where {PQ <: AbstractRationalFunction, P<:AbstractPolynomial}
-    Q = eltype(PQ)
-    q = convert(Q, p)
-    rational_function(PQ, q, one(q))
+    T′ = _eltype(_eltype((PQ)))
+    T =  T′ == nothing ? eltype(p) : T′
+    X = indeterminate(PQ, p)
+
+    𝐩 = convert(Polynomial{T,X}, p)
+    rational_function(PQ, 𝐩, one(𝐩))
 end
 
+
+
+
 function Base.convert(::Type{P}, pq::PQ) where {P<:AbstractPolynomial, PQ<:AbstractRationalFunction}
     p,q = pqs(pq)
     isconstant(q) || throw(ArgumentError("Can't convert rational function with non-constant denominator to a polynomial."))
@@ -71,6 +92,7 @@ end
 
 
 
+
 # promotion rule to promote things upwards
 function Base.promote_rule(::Type{PQ}, ::Type{PQ′}) where {T,X,P,PQ <: AbstractRationalFunction{T,X,P},
                                                            T′,X′,P′,PQ′<:AbstractRationalFunction{T′,X′,P′} }
@@ -137,7 +159,10 @@ Base.eltype(pq::Type{<:AbstractRationalFunction{T,X,P}}) where {T,X,P} = P
 Base.eltype(pq::Type{<:AbstractRationalFunction{T,X}}) where {T,X} = Polynomial{T,X}
 Base.eltype(pq::Type{<:AbstractRationalFunction{T}}) where {T} = Polynomial{T,:x}
 Base.eltype(pq::Type{<:AbstractRationalFunction}) = Polynomial{Float64,:x}
-
+_eltype(pq::Type{<:AbstractRationalFunction{T,X,P}}) where {T,X,P} = P
+_eltype(pq::Type{<:AbstractRationalFunction{T,X}}) where {T,X} = Polynomial{T,X}
+_eltype(pq::Type{<:AbstractRationalFunction{T}}) where {T} = Polynomial{T}
+_eltype(pq::Type{<:AbstractRationalFunction})  = Polynomial
 
 """
     pqs(pq) 
@@ -178,7 +203,9 @@ function indeterminate(::Type{PQ}, var=:x) where {PQ<:AbstractRationalFunction}
     X = X′ == nothing ? Symbol(var) : X′
     X
 end
-
+function indeterminate(PP::Type{P}, p::AbstractPolynomial{T,Y}) where {P <: AbstractRationalFunction, T,Y}
+    indeterminate(PP, Y)
+end
 function isconstant(pq::AbstractRationalFunction; kwargs...)
     p,q = pqs(lowest_terms(pq, kwargs...))
     isconstant(p) && isconstant(q)

src/rational-functions/rational-function.jl

@@ -55,6 +55,14 @@ end
 
 RationalFunction(p,q)  = RationalFunction(promote(p,q)...)
 RationalFunction(p::ImmutablePolynomial,q::ImmutablePolynomial) = throw(ArgumentError("Sorry, immutable #polynomials are not a valid polynomial type for RationalFunction"))
+function RationalFunction(p::LaurentPolynomial,q::LaurentPolynomial)
+    𝐩 = convert(RationalFunction, p)
+    𝐪 = convert(RationalFunction, q)
+    𝐩 // 𝐪
+end
+RationalFunction(p::LaurentPolynomial,q::Number) = convert(RationalFunction, p) // q
+RationalFunction(p::Number,q::LaurentPolynomial) = q // convert(RationalFunction, p)
+
 RationalFunction(p::AbstractPolynomial) = RationalFunction(p,one(p))
 
 # evaluation

test/rational-functions.jl

@@ -72,6 +72,13 @@ using LinearAlgebra
     x = variable(p)
     @test (x*p)//x ≈ p // one(p)
 
+    # issue 344 with LaurentPolynomials
+    p = LaurentPolynomial([24,10,-15,0,1],-2,:z)
+    q = ChebyshevT([1, 0, 3, 4],:z)
+    @test RationalFunction(p,1) == p
+    @test p //q == 1/ (q//p)
+    @test numerator(p) == p * variable(p)^2
+    @test denominator(p) == convert(Polynomial, variable(p)^2)
 
 end