handle compatability differently

Author: jverzani

src/Polynomials.jl

@@ -10,13 +10,12 @@ include("contrib.jl")
 
 # Polynomials
 include("polynomials/Polynomial.jl")
-include("polynomials/ChebyshevT.jl")
-#include("polynomials/ChebyshevU.jl")
 
+include("polynomials/ChebyshevT.jl")
 
-include("polynomials/Poly.jl") # to be deprecated, then removed
+# to be deprecated, then removed
+include("polynomials/Poly.jl")
 include("pade.jl")
-include("compat.jl") # Where we keep deprecations
 
 # Interface for all AbstractPolynomials
 include("common.jl")

src/common.jl

@@ -388,6 +388,17 @@ end
 
 Base.collect(p::P) where {P <: AbstractPolynomial} = collect(P, p)
 
+function Base.getproperty(p::AbstractPolynomial, nm::Symbol)
+    if nm == :a
+        Base.depwarn("AbstractPolynomial.a is deprecated, use AbstractPolynomial.coeffs or coeffs(AbstractPolynomial) instead.",
+            Symbol("Base.getproperty"),
+        )
+        return getfield(p, :coeffs)
+    end
+    return getfield(p, nm)
+end
+
+
 # getindex
 function Base.getindex(p::AbstractPolynomial{T}, idx::Int) where {T <: Number}
     idx < 0 && throw(BoundsError(p, idx))

src/compat.jl

@@ -2,30 +2,21 @@
 ## then deprecate these
 ## then release v1.0
 
-poly(r, var = :x) = fromroots(Polynomial, r; var = var)
-polyval(p::AbstractPolynomial, x::Number) = p(x)
-polyval(p::AbstractPolynomial, x) = p.(x)
-
-function Base.getproperty(p::AbstractPolynomial, nm::Symbol)
-    if nm == :a
-        #Base.depwarn("AbstracPolynomial.a is deprecated, use AbstracPolynomial.coeffs or coeffs(AbstractPolynomial) instead.",
-        #    Symbol("Base.getproperty"),
-        #)
-        return getfield(p, :coeffs)
-    end
-    return getfield(p, nm)
-end
-
-polyint(p::AbstractPolynomial, C = 0) = integrate(p, C)
-polyint(p::AbstractPolynomial, a, b) = integrate(p, a, b)
-polyder(p::AbstractPolynomial, ord = 1) = derivative(p, ord)
-polyfit(x, y, n = length(x) - 1, sym=:x) = fit(Polynomial, x, y, n; var = sym)
-polyfit(x, y, sym::Symbol) = fit(Polynomial, x, y, var = sym)
-
-padeval(PQ::Pade, x::Number) = PQ(x)
-padeval(PQ::Pade, x) = PQ.(x)
-
-export poly, polyval, polyint, polyder, polyfit, padeval
+## poly(r, var = :x) = fromroots(Polynomial, r; var = var)
+## polyval(p::AbstractPolynomial, x::Number) = p(x)
+## polyval(p::AbstractPolynomial, x) = p.(x)
+
+
+## polyint(p::AbstractPolynomial, C = 0) = integrate(p, C)
+## polyint(p::AbstractPolynomial, a, b) = integrate(p, a, b)
+## polyder(p::AbstractPolynomial, ord = 1) = derivative(p, ord)
+## polyfit(x, y, n = length(x) - 1, sym=:x) = fit(Polynomial, x, y, n; var = sym)
+## polyfit(x, y, sym::Symbol) = fit(Polynomial, x, y, var = sym)
+
+## padeval(PQ::Pade, x::Number) = PQ(x)
+## padeval(PQ::Pade, x) = PQ.(x)
+
+## export poly, polyval, polyint, polyder, polyfit, padeval
 
 
 ## @deprecate poly(r, var = :x) fromroots(Polynomial, r; var = var)

src/pade.jl

@@ -94,3 +94,10 @@ true
 ```
 """
 (PQ::Pade)(x) = PQ.p(x) / PQ.q(x)
+
+
+## Compat
+padeval(PQ::Pade, x::Number) = PQ(x)
+padeval(PQ::Pade, x) = PQ.(x)
+
+export padeval

src/polynomials/Poly.jl

@@ -1,3 +1,6 @@
+module PolyCompat
+
+using ..Polynomials
 #=
 This type is only here to provide stability while deprecating. This will eventually be removed in favor
 of `Polynomial` =#
@@ -7,7 +10,7 @@ export Poly
 struct Poly{T <: Number} <: AbstractPolynomial{T}
     coeffs::Vector{T}
     var::Symbol
-    function Poly(a::AbstractVector{T}, var::SymbolLike = :x) where {T <: Number}
+    function Poly(a::AbstractVector{T}, var::Polynomials.SymbolLike = :x) where {T <: Number}
       # if a == [] we replace it with a = [0]
 ##        Base.depwarn("Poly is deprecated and will be removed in a future release. Please use Polynomial instead", :Poly)
         if length(a) == 0
@@ -21,12 +24,16 @@ struct Poly{T <: Number} <: AbstractPolynomial{T}
     end
 end
 
-@register Poly
+Polynomials.@register Poly
+
+
+
+
 
 Base.convert(P::Type{<:Polynomial}, p::Poly{T}) where {T} = P(p.coeffs, p.var)
 
-domain(::Type{<:Poly}) = Interval(-Inf, Inf)
-mapdomain(::Type{<:Poly}, x::AbstractArray) = x
+Polynomials.domain(::Type{<:Poly}) = Interval(-Inf, Inf)
+Polynomials.mapdomain(::Type{<:Poly}, x::AbstractArray) = x
 
 function (p::Poly{T})(x::S) where {T,S}
     oS = one(x)
@@ -39,7 +46,7 @@ function (p::Poly{T})(x::S) where {T,S}
 end
 
 
-function fromroots(P::Type{<:Poly}, r::AbstractVector{T}; var::SymbolLike = :x) where {T <: Number}
+function Polynomials.fromroots(P::Type{<:Poly}, r::AbstractVector{T}; var::Polynomials.SymbolLike = :x) where {T <: Number}
     n = length(r)
     c = zeros(T, n + 1)
     c[1] = one(T)
@@ -50,7 +57,7 @@ function fromroots(P::Type{<:Poly}, r::AbstractVector{T}; var::SymbolLike = :x)
 end
 
 
-function vander(P::Type{<:Poly}, x::AbstractVector{T}, n::Integer) where {T <: Number}
+function Polynomials.vander(P::Type{<:Poly}, x::AbstractVector{T}, n::Integer) where {T <: Number}
     A = Matrix{T}(undef, length(x), n + 1)
     A[:, 1] .= one(T)
     @inbounds for i in 1:n
@@ -60,7 +67,7 @@ function vander(P::Type{<:Poly}, x::AbstractVector{T}, n::Integer) where {T <: N
 end
 
 
-function integrate(p::Poly{T}, k::S) where {T,S <: Number}
+function Polynomials.integrate(p::Poly{T}, k::S) where {T,S <: Number}
     R = promote_type(eltype(one(T) / 1), S)
     if hasnan(p) || isnan(k)
         return Poly([NaN])
@@ -75,7 +82,7 @@ function integrate(p::Poly{T}, k::S) where {T,S <: Number}
 end
 
 
-function derivative(p::Poly{T}, order::Integer = 1) where {T}
+function Polynomials.derivative(p::Poly{T}, order::Integer = 1) where {T}
     order < 0 && error("Order of derivative must be non-negative")
     order == 0 && return p
     hasnan(p) && return Poly(T[NaN], p.var)
@@ -90,7 +97,7 @@ function derivative(p::Poly{T}, order::Integer = 1) where {T}
 end
 
 
-function companion(p::Poly{T}) where T
+function Polynomials.companion(p::Poly{T}) where T
     d = length(p) - 1
     d < 1 && error("Series must have degree greater than 1")
     d == 1 && return diagm(0 => [-p[0] / p[1]])
@@ -146,4 +153,33 @@ function Base.divrem(num::Poly{T}, den::Poly{S}) where {T,S}
     return P(q_coeff, num.var), P(r_coeff, num.var)
 end
 
-showterm(io::IO, ::Type{Poly{T}}, pj::T, var, j, first::Bool, mimetype) where {T} = showterm(io, Polynomial{T}, pj, var, j, first, mimetype)
+Polynomials.showterm(io::IO, ::Type{Poly{T}}, pj::T, var, j, first::Bool, mimetype) where {T} = showterm(io, Polynomial{T}, pj, var, j, first, mimetype)
+
+
+
+## Compat
+poly(r, var = :x) = fromroots(Poly, r; var = var)
+polyval(p::Poly, x::Number) = p(x)
+polyval(p::Poly, x) = p.(x)
+
+function Base.getproperty(p::Poly, nm::Symbol)
+    if nm == :a
+        return getfield(p, :coeffs)
+    end
+    return getfield(p, nm)
+end
+
+polyint(p::Poly, C = 0) = integrate(p, C)
+polyint(p::Poly, a, b) = integrate(p, a, b)
+polyder(p::Poly, ord = 1) = derivative(p, ord)
+polyfit(x, y, n = length(x) - 1, sym=:x) = fit(Poly, x, y, n; var = sym)
+polyfit(x, y, sym::Symbol) = fit(Poly, x, y, var = sym)
+
+export poly, polyval, polyint, polyder, polyfit
+
+end
+
+## Ensure compatability for now
+using .PolyCompat
+export Poly
+export poly, polyval, polyint, polyder, polyfit, padeval

src/polynomials/Polynomial.jl

@@ -226,7 +226,7 @@ function Base.divrem(num::Polynomial{T}, den::Polynomial{S}) where {T,S}
         return zero(P), convert(P, num)
     end
     q_coeff = zeros(R, deg)
-    r_coeff = R[ num.a[i] for i in 1:n+1 ]
+    r_coeff = R[ num[i-1] for i in 1:n+1 ]
     @inbounds for i in n:-1:m
         q = r_coeff[i + 1] / den[m]
         q_coeff[i - m + 1] = q

test/runtests.jl

@@ -10,4 +10,4 @@ import SparseArrays: sparse, nnz
 @testset "Polynomial" begin include("Polynomial.jl") end
 @testset "ChebyshevT" begin include("ChebyshevT.jl") end
 #@testset "Deprecations" begin include("deprecated.jl") end
-@testset "Poly (to be deprecated)" begin include("Poly.jl") end
+@testset "Poly (compatability)" begin include("Poly.jl") end