V0.9 (#200)

* make deprecations errors

* run doctests; fix bug in  printpoly

* adjust one, zero and handling of var

* adjust documentation, move Pade tests to compatability file

* remove round function, caused issues (no deprecation phase). Close #201

Author: jverzani

Project.toml

@@ -2,16 +2,16 @@ name = "Polynomials"
 uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45"
 license = "MIT"
 author = "JuliaMath"
-version = "0.7.0"
+version = "0.9.0"
 
 [deps]
 Intervals = "d8418881-c3e1-53bb-8760-2df7ec849ed5"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 
 [compat]
-Intervals = "0.5.0, 1.0"
-RecipesBase = "0.7, 0.8, 1.0"
+Intervals = "0.5, 1"
+RecipesBase = "0.7, 0.8, 1"
 julia = "1"
 
 

README.md

@@ -141,15 +141,15 @@ julia> roots(Polynomial([0, 0, 1]))
 
 #### Fitting arbitrary data
 
-Fit a polynomial (of degree `deg`) to `x` and `y` using a least-squares approximation.
+Fit a polynomial (of degree `deg` or less) to `x` and `y` using a least-squares approximation.
 
 ```julia
 julia> xs = 0:4; ys = @. exp(-xs) + sin(xs);
 
-julia> fit(xs, ys) |> x -> round(x, digits=4)
+julia> fit(xs, ys) |> p -> round.(coeffs(p), digits=4) |> Polynomial
 Polynomial(1.0 + 0.0593*x + 0.3959*x^2 - 0.2846*x^3 + 0.0387*x^4)
 
-julia> fit(ChebyshevT, xs, ys, deg=2) |> x -> round(x, digits=4)
+julia> fit(ChebyshevT, xs, ys, 2) |> p -> round.(coeffs(p), digits=4) |> ChebyshevT
 ChebyshevT(0.5413⋅T_0(x) - 0.8991⋅T_1(x) - 0.4238⋅T_2(x))
 ```
 

docs/src/index.md

@@ -120,7 +120,7 @@ resulting polynomial is one lower than the degree of `p`.
 
 ```jldoctest
 julia> derivative(Polynomial([1, 3, -1]))
-Polynomial(3 - 2*x)
+Polynomial(3.0 - 2.0*x)
 ```
 
 ### Root-finding
@@ -132,18 +132,18 @@ the returned roots may be real or complex.
 ```jldoctest
 julia> roots(Polynomial([1, 0, -1]))
 2-element Array{Float64,1}:
-  1.0
  -1.0
+  1.0
 
 julia> roots(Polynomial([1, 0, 1]))
 2-element Array{Complex{Float64},1}:
-  0.0 - 1.0im
-  0.0 + 1.0im
+ 0.0 - 1.0im
+ 0.0 + 1.0im
 
 julia> roots(Polynomial([0, 0, 1]))
 2-element Array{Float64,1}:
-  0.0
- -0.0
+ 0.0
+ 0.0
 ```
 
 ### Fitting arbitrary data
@@ -193,6 +193,8 @@ julia> convert(ChebyshevT, Polynomial([1.0, 2,  3]))
 ChebyshevT(2.5⋅T_0(x) + 2.0⋅T_1(x) + 1.5⋅T_2(x))
 ```
 
+!!! Note
+    The older  `Poly` type that this package used prior to `v0.7`  is implemented as an alternate basis  to provide support for older code bases. As of `v1.0`,  this type will be only available by executing `using Polynomials.PolyCompat`.
 
 ### Iteration
 

docs/src/polynomials/chebyshev.md

@@ -14,7 +14,6 @@ The [Chebyshev polynomials](https://en.wikipedia.org/wiki/Chebyshev_polynomials)
 
 ```@docs
 ChebyshevT
-ChebyshevT()
 ```
 
 The `ChebyshevT` type holds coefficients representing the polynomial `a_0 T_0 + a_1 T_1 + ... + a_n T_n`.

docs/src/polynomials/polynomial.md

@@ -8,7 +8,6 @@ end
 
 ```@docs
 Polynomial
-Polynomial()
 ```
 
 ```@docs

docs/src/reference.md

@@ -23,7 +23,6 @@ domain
 mapdomain
 chop
 chop!
-round
 truncate
 truncate!
 ```

src/abstract.jl

@@ -3,15 +3,15 @@ export AbstractPolynomial
 const SymbolLike = Union{AbstractString,Char,Symbol}
 
 """
-    AbstractPolynomial{<:Number}
+    AbstractPolynomial{T}
 
 An abstract container for various polynomials. 
 
 # Properties
 - `coeffs` - The coefficients of the polynomial
 - `var` - The indeterminate of the polynomial
 """
-abstract type AbstractPolynomial{T<:Number} end
+abstract type AbstractPolynomial{T} end
 
 
 """
@@ -29,7 +29,7 @@ Polynomials.@register MyPolynomial
 # Implementations
 This will implement simple self-conversions like `convert(::Type{MyPoly}, p::MyPoly) = p` and creates two promote rules. The first allows promotion between two types (e.g. `promote(Polynomial, ChebyshevT)`) and the second allows promotion between parametrized types (e.g. `promote(Polynomial{T}, Polynomial{S})`). 
 
-For constructors, it implements the shortcut for `MyPoly(...) = MyPoly{T}(...)`, singleton constructor `MyPoly(x::Number, ...)`, and conversion constructor `MyPoly{T}(n::S, ...)`.
+For constructors, it implements the shortcut for `MyPoly(...) = MyPoly{T}(...)`, singleton constructor `MyPoly(x::Number, ...)`,  conversion constructor `MyPoly{T}(n::S, ...)`, and `variable` alternative  `MyPoly(var=:x)`.
 """
 macro register(name)
     poly = esc(name)
@@ -40,19 +40,12 @@ macro register(name)
             $poly{promote_type(T, S)}
         Base.promote_rule(::Type{$poly{T}}, ::Type{S}) where {T,S<:Number} =
             $poly{promote_type(T, S)}
-
-        function (p::$poly)(x::AbstractVector)
-            Base.depwarn(
-                "Calling p(x::AbstractVector is deprecated. Use p.(x) instead.",
-                Symbol("(p::AbstractPolynomial)"),
-            )
-            return p.(x)
-        end
-
         $poly(coeffs::AbstractVector{T}, var::SymbolLike = :x) where {T} =
             $poly{T}(coeffs, Symbol(var))
-        $poly(n::Number, var = :x) = $poly([n], var)
-        $poly{T}(n::S, var = :x) where {T,S<:Number} = $poly(T(n), var)
         $poly{T}(x::AbstractVector{S}, var = :x) where {T,S<:Number} = $poly(T.(x), var)
+        $poly{T}(n::Number, var = :x) where {T} = $poly(T(n), var)
+        $poly(n::Number, var = :x) = $poly([n], var)
+        $poly{T}(var=:x) where {T} = variable($poly{T}, var)
+        $poly(var=:x) = variable($poly, var)
     end
 end

src/common.jl

@@ -24,7 +24,9 @@ export fromroots,
 Construct a polynomial of the given type given the roots. If no type is given, defaults to `Polynomial`.
 
 # Examples
-```jldoctest
+```jldoctest common
+julia> using Polynomials
+
 julia> r = [3, 2]; # (x - 3)(x - 2)
 
 julia> fromroots(r)
@@ -46,7 +48,9 @@ fromroots(r::AbstractVector{<:Number}; var::SymbolLike = :x) =
 Construct a polynomial of the given type using the eigenvalues of the given matrix as the roots. If no type is given, defaults to `Polynomial`.
 
 # Examples
-```jldoctest
+```jldoctest common
+julia> using Polynomials
+
 julia> A = [1 2; 3 4]; # (x - 5.37228)(x + 0.37228)
 
 julia> fromroots(A)
@@ -195,11 +199,11 @@ In-place version of [`chop`](@ref)
 function chop!(p::AbstractPolynomial{T};
     rtol::Real = Base.rtoldefault(real(T)),
                atol::Real = 0,) where {T}
-    degree(p) == -1 && return p
+    isempty(coeffs(p)) && return p
     for i = lastindex(p):-1:0
         val = p[i]
         if !isapprox(val, zero(T); rtol = rtol, atol = atol)
-            resize!(p.coeffs, i + 1)
+            resize!(p.coeffs, i + 1); 
             return p
         end
     end
@@ -219,22 +223,18 @@ function Base.chop(p::AbstractPolynomial{T};
     chop!(deepcopy(p), rtol = rtol, atol = atol)
 end
 
-"""
-    round(p::AbstractPolynomial, args...; kwargs)
-
-Applies `round` to  the cofficients  of `p` with the given arguments. Returns a new polynomial.
-"""
-Base.round(p::P, args...;kwargs...) where {P <: AbstractPolynomial} = P(round.(coeffs(p), args...; kwargs...), p.var)
 
 """
     variable(var=:x)
     variable(::Type{<:AbstractPolynomial}, var=:x)
     variable(p::AbstractPolynomial, var=p.var)
 
-Return the monomial `x` in the indicated polynomial basis.  If no type is give, will default to [`Polynomial`](@ref).
+Return the monomial `x` in the indicated polynomial basis.  If no type is give, will default to [`Polynomial`](@ref). Equivalent  to  `P(var)`.
 
 # Examples
-```jldoctest
+```jldoctest  common
+julia> using Polynomials
+
 julia> x = variable()
 Polynomial(x)
 
@@ -243,8 +243,8 @@ Polynomial(100 + 24*x - 3*x^2)
 
 julia> roots((x - 3) * (x + 2))
 2-element Array{Float64,1}:
-  3.0
  -2.0
+  3.0
 
 ```
 """
@@ -299,7 +299,7 @@ function Base.iszero(p::AbstractPolynomial)
     if length(p) == 0
         return true
     end
-    return length(p) == 1 && p[0] == 0
+    return all(iszero.(coeffs(p))) && p[0] == 0
 end
 
 """
@@ -334,7 +334,9 @@ domain(::P) where {P <: AbstractPolynomial} = domain(P)
 Given values of x that are assumed to be unbounded (-∞, ∞), return values rescaled to the domain of the given polynomial.
 
 # Examples
-```jldoctest
+```jldoctest  common
+julia> using Polynomials
+
 julia> x = -10:10
 -10:10
 
@@ -383,10 +385,7 @@ 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)
+        throw(ArgumentError("AbstractPolynomial.a is not supported, use coeffs(AbstractPolynomial) instead."))
     end
     return getfield(p, nm)
 end
@@ -434,16 +433,16 @@ Base.hash(p::AbstractPolynomial, h::UInt) = hash(p.var, hash(coeffs(p), h))
 
 Returns a representation of 0 as the given polynomial.
 """
-Base.zero(::Type{P}) where {P <: AbstractPolynomial} = P(zeros(1))
-Base.zero(p::P) where {P <: AbstractPolynomial} = zero(P)
+Base.zero(::Type{P}, var=:x) where {P <: AbstractPolynomial} = P(zeros(1), var)
+Base.zero(p::P) where {P <: AbstractPolynomial} = zero(P, p.var)
 """
     one(::Type{<:AbstractPolynomial})
     one(::AbstractPolynomial)
 
 Returns a representation of 1 as the given polynomial.
 """
-Base.one(::Type{P}) where {P <: AbstractPolynomial} = P(ones(1))
-Base.one(p::P) where {P <: AbstractPolynomial} = one(P)
+Base.one(::Type{P}, var=:x) where {P <: AbstractPolynomial} = P(ones(1), var)
+Base.one(p::P) where {P <: AbstractPolynomial} = one(P, p.var)
 
 #=
 arithmetic =#
@@ -493,7 +492,9 @@ Find the greatest common denominator of two polynomials recursively using
 
 # Examples
 
-```jldoctest
+```jldoctest common
+julia> using Polynomials
+
 julia> gcd(fromroots([1, 1, 2]), fromroots([1, 2, 3]))
 Polynomial(4.0 - 6.0*x + 2.0*x^2)
 
@@ -504,7 +505,7 @@ function Base.gcd(p1::AbstractPolynomial{T}, p2::AbstractPolynomial{S}) where {T
     iter = 1
     itermax = length(r₁)
 
-    while r₁ ≉ zero(r₁) && iter ≤ itermax   # just to avoid unnecessary recursion
+    while !iszero(r₁) && iter ≤ itermax
         _, rtemp = divrem(r₀, r₁)
         r₀ = r₁
         r₁ = truncate(rtemp)  

src/compat.jl

@@ -4,33 +4,14 @@
 ## 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.
-
-## Ensure compatability for now
-@deprecate polyval(p::AbstractPolynomial, x::Number)  p(x)
-@deprecate polyval(p::AbstractPolynomial, x)  p.(x)
-
-
-@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, sym=:x)  fit(Poly, x, y, n; var = sym)
-@deprecate polyfit(x, y, sym::Symbol)  fit(Poly, x, y, var = sym)
+## At v1.0, these will be opt-in via `using Polynomials.PolyCompat`
 
 
 include("polynomials/Poly.jl")
 using .PolyCompat
 export Poly
-export poly, polyval, polyint, polyder, polyfit
-
-
-
+export poly, polyval, polyint, polyder
 
 ## Pade
-## Pade will  likely be moved into a separate pacakge
-include("pade.jl")
-using .PadeApproximation
-export Pade
-export padeval
+## Pade will  likely be moved into a separate package, for now we will put into PolyCompat
+export Pade, padeval