change handling of compat

Author: jverzani

src/Polynomials.jl

@@ -8,16 +8,15 @@ include("show.jl")
 include("plots.jl")
 include("contrib.jl")
 
+# Interface for all AbstractPolynomials
+include("common.jl")
+
+
 # Polynomials
 include("polynomials/Polynomial.jl")
-
 include("polynomials/ChebyshevT.jl")
 
 # to be deprecated, then removed
-include("polynomials/Poly.jl")
-include("pade.jl")
-
-# Interface for all AbstractPolynomials
-include("common.jl")
+include("compat.jl")
 
 end # module

src/common.jl

@@ -354,9 +354,22 @@ function mapdomain(P::Type{<:AbstractPolynomial}, x::AbstractArray)
 end
 mapdomain(::P, x::AbstractArray) where {P <: AbstractPolynomial} = mapdomain(P, x)
 
+"""
+    mapdomain(P::Type{<:AbstractPolynomial}, a , b)
+
+Returns a *linear* function ϕ: [a,b] -> domain(P)
+
+If either endpoint if infinite, returns `identity`.
+"""
 function mapdomain(P::Type{<:AbstractPolynomial}, a::Number, b::Number)
     a, b = a < b ? (a,b) : (b,a)
-    x -> mapdomain(P, [a,x,b])[2]
+    dom = domain(P)
+    m, M = first(dom), last(dom)
+    (isinf(a) || isinf(b) || isinf(m) || isinf(M)) && return  x -> x
+    x -> begin
+        lambda = (x-a)/(b-a)
+        m + lambda * (last(dom) - first(dom))
+    end
 end
 
 #=

src/compat.jl

@@ -1,43 +1,36 @@
+## We have renamed the MATLAB/numpy type names to more Julian names
+## How to keep the old names during a transition is the question.
 ## The plan: keep these to ensure underlying changes are not disruptive
-## then deprecate these
-## then release v1.0
+## For now  we ensure compatability by defining these for `Poly` objects such
+## that they do not signal a deprecation (save polyfit)),
+## but  do for other `AbstractPolynomial` types.
+## At v1.0, it is likely these will be removed.
 
-## poly(r, var = :x) = fromroots(Polynomial, r; var = var)
-## polyval(p::AbstractPolynomial, x::Number) = p(x)
-## polyval(p::AbstractPolynomial, x) = p.(x)
+## Ensure compatability for now
+@deprecate polyval(p::AbstractPolynomial, x::Number)  p(x)
+@deprecate 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)
+@deprecate polyint(p::AbstractPolynomial, C = 0)  integrate(p, C)
+@deprecate polyint(p::AbstractPolynomial, a, b)  integrate(p, a, b)
 
-## padeval(PQ::Pade, x::Number) = PQ(x)
-## padeval(PQ::Pade, x) = PQ.(x)
+@deprecate polyder(p::AbstractPolynomial, ord = 1)  derivative(p, ord)
 
-## export poly, polyval, polyint, polyder, polyfit, padeval
+@deprecate polyfit(x, y, n = length(x) - 1, sym=:x)  fit(Poly, x, y, n; var = sym)
+@deprecate polyfit(x, y, sym::Symbol)  fit(Poly, x, y, var = sym)
 
 
-## @deprecate poly(r, var = :x) fromroots(Polynomial, r; var = var)
-## @deprecate polyval(p::AbstractPolynomial, x::Number) p(x)
-## @deprecate polyval(p::AbstractPolynomial, x) p.(x)
+include("polynomials/Poly.jl")
+using .PolyCompat
+export Poly
+export poly, polyval, polyint, polyder, polyfit
 
-## 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
 
-## @deprecate polyint(p::AbstractPolynomial, C = 0) integrate(p, C)
-## @deprecate polyint(p::AbstractPolynomial, a, b) integrate(p, a, b)
-## @deprecate polyder(p::AbstractPolynomial, ord = 1) derivative(p, ord)
-## @deprecate polyfit(x, y, n = length(x) - 1) fit(Polynomial, x, y; deg = n)
-## @deprecate polyfit(x, y, sym::Symbol) fit(Polynomial, x, y; var = sym)
 
-## @deprecate padeval(PQ::Pade, x::Number) PQ(x)
-## @deprecate padeval(PQ::Pade, x) PQ.(x)
+
+## Pade
+## Pade will  likely be moved into a separate pacakge
+include("pade.jl")
+using .PadeApproximation
+export Pade
+export padeval

src/pade.jl

@@ -1,3 +1,8 @@
+module PadeApproximation
+
+using ..Polynomials
+export Pade, padeval
+
 #=
 Pade approximation
 
@@ -100,4 +105,6 @@ true
 padeval(PQ::Pade, x::Number) = PQ(x)
 padeval(PQ::Pade, x) = PQ.(x)
 
-export padeval
+
+
+end

src/polynomials/Poly.jl

@@ -1,6 +1,8 @@
 module PolyCompat
 
 using ..Polynomials
+export poly, polyval, polyint, polyder, polyfit
+
 #=
 This type is only here to provide stability while deprecating. This will eventually be removed in favor
 of `Polynomial` =#
@@ -32,7 +34,7 @@ Polynomials.@register Poly
 
 Base.convert(P::Type{<:Polynomial}, p::Poly{T}) where {T} = P(p.coeffs, p.var)
 
-Polynomials.domain(::Type{<:Poly}) = Interval(-Inf, Inf)
+Polynomials.domain(::Type{<:Poly}) = Polynomials.Interval(-Inf, Inf)
 Polynomials.mapdomain(::Type{<:Poly}, x::AbstractArray) = x
 
 function (p::Poly{T})(x::S) where {T,S}
@@ -159,8 +161,9 @@ Polynomials.showterm(io::IO, ::Type{Poly{T}}, pj::T, var, j, first::Bool, mimety
 
 ## Compat
 poly(r, var = :x) = fromroots(Poly, r; var = var)
-polyval(p::Poly, x::Number) = p(x)
-polyval(p::Poly, x) = p.(x)
+
+Polynomials.polyval(p::Poly, x::Number) = p(x)
+Polynomials.polyval(p::Poly, x) = p.(x)
 
 function Base.getproperty(p::Poly, nm::Symbol)
     if nm == :a
@@ -169,17 +172,8 @@ function Base.getproperty(p::Poly, nm::Symbol)
     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
+Polynomials.polyint(p::Poly, C = 0) = integrate(p, C)
+Polynomials.polyint(p::Poly, a, b) = integrate(p, a, b)
+Polynomials.polyder(p::Poly, ord = 1) = derivative(p, ord)
 
 end
-
-## Ensure compatability for now
-using .PolyCompat
-export Poly
-export poly, polyval, polyint, polyder, polyfit, padeval