Merge pull request #222 from jverzani/v1.1.0

V1.1.0: 
change  eltype(::Type{Polynomial}) (breaks non documented feature)
improve ImmutablePolynomial (breaks non  documented order  of type parameters)
clean up

Author: jverzani

Project.toml

@@ -3,7 +3,7 @@ name = "Polynomials"
 uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45"
 license = "MIT"
 author = "JuliaMath"
-version = "1.0.6"
+version = "1.1.0"
 
 [deps]
 Intervals = "d8418881-c3e1-53bb-8760-2df7ec849ed5"

src/abstract.jl

@@ -13,6 +13,9 @@ An abstract container for various polynomials.
 """
 abstract type AbstractPolynomial{T} end
 
+# We want  ⟒(P{α…,T}) = P{α…}; this default
+# works for most cases
+⟒(P::Type{<:AbstractPolynomial}) = constructorof(P)
 
 """
     Polynomials.@register(name)
@@ -36,17 +39,18 @@ macro register(name)
     quote
         Base.convert(::Type{P}, p::P) where {P<:$poly} = p
         Base.convert(P::Type{<:$poly}, p::$poly{T}) where {T} = P(coeffs(p), p.var)
-        Base.promote_rule(::Type{$poly{T}}, ::Type{$poly{S}}) where {T,S} =
+        Base.promote(p::P, q::Q) where {T, P <:$poly{T}, Q <: $poly{T}} = p,q
+        Base.promote_rule(::Type{<:$poly{T}}, ::Type{<:$poly{S}}) where {T,S} =
             $poly{promote_type(T, S)}
-        Base.promote_rule(::Type{$poly{T}}, ::Type{S}) where {T,S<:Number} =
+        Base.promote_rule(::Type{<:$poly{T}}, ::Type{S}) where {T,S<:Number} =
             $poly{promote_type(T, S)}
         $poly(coeffs::AbstractVector{T}, var::SymbolLike = :x) where {T} =
             $poly{T}(coeffs, Symbol(var))
-        $poly{T}(x::AbstractVector{S}, var = :x) where {T,S<:Number} =
-            $poly(T.(x), var)
-        $poly{T}(n::S, var = :x) where {T, S<:Number} =
-            $poly(T[n], var)
-        $poly(n::Number, var = :x) = $poly([n], var)
+        $poly{T}(x::AbstractVector{S}, var::SymbolLike = :x) where {T,S<:Number} =
+            $poly(T.(x), Symbol(var))
+        $poly{T}(n::S, var::SymbolLike = :x) where {T, S<:Number} =
+            $poly(T[n], Symbol(var))
+        $poly(n::Number, var::SymbolLike = :x) = $poly([n], Symbol(var))
         $poly{T}(var::SymbolLike=:x) where {T} = variable($poly{T}, Symbol(var))
         $poly(var::SymbolLike=:x) = variable($poly, Symbol(var))
     end
@@ -58,19 +62,20 @@ macro register1(name)
     poly = esc(name)
     quote
         Base.convert(::Type{P}, p::P) where {P<:$poly} = p
-        Base.promote_rule(::Type{$poly{α,T}}, ::Type{$poly{α,S}}) where {α,T,S} =
+        Base.promote(p::P, q::Q) where {α,T, P <:$poly{α,T}, Q <: $poly{α,T}} = p,q
+        Base.promote_rule(::Type{<:$poly{α,T}}, ::Type{<:$poly{α,S}}) where {α,T,S} =
             $poly{α,promote_type(T, S)}
-        Base.promote_rule(::Type{$poly{α,T}}, ::Type{S}) where {α,T,S<:Number} = 
+        Base.promote_rule(::Type{<:$poly{α,T}}, ::Type{S}) where {α,T,S<:Number} = 
             $poly{α,promote_type(T,S)}
-        function $poly{α,T}(x::AbstractVector{S}, var::Polynomials.SymbolLike = :x) where {α,T,S}
+        function $poly{α,T}(x::AbstractVector{S}, var::SymbolLike = :x) where {α,T,S}
             $poly{α,T}(T.(x), Symbol(var))
         end
-        $poly{α}(coeffs::AbstractVector{T}, var::Polynomials.SymbolLike=:x) where {α,T} =
+        $poly{α}(coeffs::AbstractVector{T}, var::SymbolLike=:x) where {α,T} =
             $poly{α,T}(coeffs, Symbol(var))
-        $poly{α,T}(n::Number, var::Polynomials.SymbolLike = :x) where {α,T} = n*one($poly{α,T}, Symbol(var))
-        $poly{α}(n::Number, var::Polynomials.SymbolLike = :x) where {α} = n*one($poly{α}, Symbol(var))
-        $poly{α,T}(var::Polynomials.SymbolLike=:x) where {α, T} = variable($poly{α,T}, Symbol(var))
-        $poly{α}(var::Polynomials.SymbolLike=:x) where {α} = variable($poly{α}, Symbol(var))
+        $poly{α,T}(n::Number, var::SymbolLike = :x) where {α,T} = n*one($poly{α,T}, Symbol(var))
+        $poly{α}(n::Number, var::SymbolLike = :x) where {α} = n*one($poly{α}, Symbol(var))
+        $poly{α,T}(var::SymbolLike=:x) where {α, T} = variable($poly{α,T}, Symbol(var))
+        $poly{α}(var::SymbolLike=:x) where {α} = variable($poly{α}, Symbol(var))
     end
 end
 
@@ -80,17 +85,18 @@ macro register2(name)
     poly = esc(name)
     quote
         Base.convert(::Type{P}, p::P) where {P<:$poly} = p
-        Base.promote_rule(::Type{$poly{α,β,T}}, ::Type{$poly{α,β,S}}) where {α,β,T,S} =
+        Base.promote(p::P, q::Q) where {α,β,T, P <:$poly{α,β,T}, Q <: $poly{α,β,T}} = p,q        
+        Base.promote_rule(::Type{<:$poly{α,β,T}}, ::Type{<:$poly{α,β,S}}) where {α,β,T,S} =
             $poly{α,β,promote_type(T, S)}
-        Base.promote_rule(::Type{$poly{α,β,T}}, ::Type{S}) where {α,β,T,S<:Number} =
+        Base.promote_rule(::Type{<:$poly{α,β,T}}, ::Type{S}) where {α,β,T,S<:Number} =
             $poly{α,β,promote_type(T, S)}
-        $poly{α,β}(coeffs::AbstractVector{T}, var::Polynomials.SymbolLike = :x) where {α,β,T} =
+        $poly{α,β}(coeffs::AbstractVector{T}, var::SymbolLike = :x) where {α,β,T} =
             $poly{α,β,T}(coeffs, Symbol(var))
-        $poly{α,β,T}(x::AbstractVector{S}, var = :x) where {α,β,T,S<:Number} = $poly{α,β,T}(T.(x), var)
-        $poly{α,β,T}(n::Number, var = :x) where {α,β,T} = n*one($poly{α,β,T}, var)
-        $poly{α,β}(n::Number, var = :x) where {α,β} = n*one($poly{α,β}, var)
-        $poly{α,β,T}(var=:x) where {α,β, T} = variable($poly{α,β,T}, var)
-        $poly{α,β}(var=:x) where {α,β} = variable($poly{α,β}, var)
+        $poly{α,β,T}(x::AbstractVector{S}, var::SymbolLike = :x) where {α,β,T,S<:Number} = $poly{α,β,T}(T.(x), var)
+        $poly{α,β,T}(n::Number, var::SymbolLike = :x) where {α,β,T} = n*one($poly{α,β,T}, Symbol(var))
+        $poly{α,β}(n::Number, va::SymbolLiker = :x) where {α,β} = n*one($poly{α,β}, Symbol(var))
+        $poly{α,β,T}(var::SymbolLike=:x) where {α,β, T} = variable($poly{α,β,T}, Symbol(var))
+        $poly{α,β}(var::SymbolLike=:x) where {α,β} = variable($poly{α,β}, Symbol(var))
     end
 end
 

src/common.jl

@@ -172,7 +172,7 @@ In-place version of [`truncate`](@ref)
 """
 function truncate!(p::AbstractPolynomial{T};
     rtol::Real = Base.rtoldefault(real(T)),
-    atol::Real = 0,) where {T}
+                   atol::Real = 0,) where {T}
     max_coeff = maximum(abs, coeffs(p))
     thresh = max_coeff * rtol + atol
     map!(c->abs(c) <= thresh ? zero(T) : c, coeffs(p), coeffs(p))
@@ -225,33 +225,7 @@ function Base.chop(p::AbstractPolynomial{T};
 end
 
 
-"""
-    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). Equivalent  to  `P(var)`.
-
-# Examples
-```jldoctest  common
-julia> using Polynomials
-
-julia> x = variable()
-Polynomial(x)
-
-julia> p = 100 + 24x - 3x^2
-Polynomial(100 + 24*x - 3*x^2)
-
-julia> roots((x - 3) * (x + 2))
-2-element Array{Float64,1}:
- -2.0
-  3.0
 
-```
-"""
-variable(::Type{P}, var::SymbolLike = :x) where {P <: AbstractPolynomial} = P([0, 1], var)
-variable(p::AbstractPolynomial, var::SymbolLike = p.var) = variable(typeof(p), var)
-variable(var::SymbolLike = :x) = variable(Polynomial{Int})
 
 """
     check_same_variable(p::AbstractPolynomial, q::AbstractPolynomial)
@@ -303,7 +277,10 @@ Returns the size of the polynomials coefficients, along axis `i` if provided.
 Base.size(p::AbstractPolynomial) = size(coeffs(p))
 Base.size(p::AbstractPolynomial, i::Integer) = size(coeffs(p), i)
 Base.eltype(p::AbstractPolynomial{T}) where {T} = T
-Base.eltype(::Type{P}) where {P <: AbstractPolynomial} = P
+# in  analogy  with  polynomial as a Vector{T} with different operations defined.
+Base.eltype(::Type{<:AbstractPolynomial}) = Float64
+Base.eltype(::Type{<:AbstractPolynomial{T}}) where {T} = T
+#Base.eltype(::Type{P}) where {P <: AbstractPolynomial} = P # changed  in v1.1.0
 function Base.iszero(p::AbstractPolynomial)
     if length(p) == 0
         return true
@@ -381,18 +358,6 @@ Base.lastindex(p::AbstractPolynomial) = length(p) - 1
 Base.eachindex(p::AbstractPolynomial) = 0:length(p) - 1
 Base.broadcastable(p::AbstractPolynomial) = Ref(p)
 
-# basis
-# return the kth basis polynomial for the given polynomial type, e.g. x^k for Polynomial{T}
-function basis(p::P, k::Int; var=:x) where {P<:AbstractPolynomial}
-    basis(P, k, var=var)
-end
-
-function basis(::Type{P}, k::Int; var=:x) where {P <: AbstractPolynomial}
-    zs = zeros(Int, k+1)
-    zs[end] = 1
-    P(zs, var)
-end
-
 # iteration
 # iteration occurs over the basis polynomials
 Base.iterate(p::AbstractPolynomial) = (p[0] * one(typeof(p)), 1)
@@ -439,26 +404,70 @@ Base.setindex!(p::AbstractPolynomial, values, ::Colon) =
 identity =#
 Base.copy(p::P) where {P <: AbstractPolynomial} = P(copy(coeffs(p)), p.var)
 Base.hash(p::AbstractPolynomial, h::UInt) = hash(p.var, hash(coeffs(p), h))
+
+#=
+zero, one, variable, basis =#
 """
     zero(::Type{<:AbstractPolynomial})
     zero(::AbstractPolynomial)
 
 Returns a representation of 0 as the given polynomial.
 """
-Base.zero(::Type{P}, var=:x) where {T, P <: AbstractPolynomial{T}} = P(zeros(T, 1), var)
-Base.zero(::Type{P}, var=:x) where {P <: AbstractPolynomial} = P(zeros(1), var)
+Base.zero(::Type{P}, var=:x) where {P <: AbstractPolynomial} = ⟒(P)(zeros(eltype(P), 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}, var=:x) where {T, P <: AbstractPolynomial{T}} = P(ones(T, 1), var)
-Base.one(::Type{P}, var=:x) where {P <: AbstractPolynomial} = P(ones(1), var)
+Base.one(::Type{P}, var=:x) where {P <: AbstractPolynomial} = ⟒(P)(ones(eltype(P),1), var)
 Base.one(p::P) where {P <: AbstractPolynomial} = one(P, p.var)
-Base.oneunit(p::P, args...) where {P <: AbstractPolynomial} = one(p, args...)
+
 Base.oneunit(::Type{P}, args...) where {P <: AbstractPolynomial} = one(P, args...)
+Base.oneunit(p::P, args...) where {P <: AbstractPolynomial} = one(p, args...)
+
+
+"""
+    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). Equivalent  to  `P(var)`.
+
+# Examples
+```jldoctest  common
+julia> using Polynomials
+
+julia> x = variable()
+Polynomial(x)
+
+julia> p = 100 + 24x - 3x^2
+Polynomial(100 + 24*x - 3*x^2)
+
+julia> roots((x - 3) * (x + 2))
+2-element Array{Float64,1}:
+ -2.0
+  3.0
+
+```
+"""
+variable(::Type{P}, var::SymbolLike = :x) where {P <: AbstractPolynomial} = MethodError()
+variable(p::AbstractPolynomial, var::SymbolLike = p.var) = variable(typeof(p), var)
+variable(var::SymbolLike = :x) = variable(Polynomial{Int}, var)
+
+# basis
+# var is a positional argument, not a keyword; can't deprecate so we do `_var; var=_var`
+#@deprecate basis(p::P, k::Int; var=:x)  where {P<:AbstractPolynomial}  basis(p, k, var)
+#@deprecate basis(::Type{P}, k::Int; var=:x) where {P <: AbstractPolynomial} basis(P, k,var)
+# return the kth basis polynomial for the given polynomial type, e.g. x^k for Polynomial{T}
+function basis(::Type{P}, k::Int, _var::SymbolLike=:x; var=_var) where {P <: AbstractPolynomial}
+    zs = zeros(Int, k+1)
+    zs[end] = 1
+    ⟒(P){eltype(P)}(zs, var)
+end
+basis(p::P, k::Int, _var::SymbolLike=:x; var=_var) where {P<:AbstractPolynomial} = basis(P, k, var)
+
 #=
 arithmetic =#
 Base.:-(p::P) where {P <: AbstractPolynomial} = P(-coeffs(p), p.var)

src/contrib.jl

@@ -33,6 +33,7 @@ end
 ## Slight modification when `x` is a matrix
 ## Remove once dependencies for Julia 1.0.0 are dropped
 function evalpoly(x::S, p::Tuple) where {S}
+    p == () && return zero(S)
     if @generated
         N = length(p.parameters)
         ex = :(p[end]*_one(S))

src/polynomials/ChebyshevT.jl

@@ -59,7 +59,7 @@ function Base.convert(C::Type{<:ChebyshevT}, p::Polynomial)
 end
 
 domain(::Type{<:ChebyshevT}) = Interval(-1, 1)
-
+variable(P::Type{<:ChebyshevT}, var::SymbolLike=:x ) = P([0,1], var)
 """
     (::ChebyshevT)(x)