modify eltype(P), clean up functions

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/common.jl

@@ -249,9 +249,9 @@ julia> roots((x - 3) * (x + 2))
 
 ```
 """
-variable(::Type{P}, var::SymbolLike = :x) where {P <: AbstractPolynomial} = P([0, 1], var)
+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})
+variable(var::SymbolLike = :x) = variable(Polynomial{Int}, var)
 
 """
     check_same_variable(p::AbstractPolynomial, q::AbstractPolynomial)
@@ -303,7 +303,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
@@ -382,16 +385,20 @@ Base.eachindex(p::AbstractPolynomial) = 0:length(p) - 1
 Base.broadcastable(p::AbstractPolynomial) = Ref(p)
 
 # 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(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}
+function basis(::Type{P}, k::Int, _var::SymbolLike=:x; var=_var) where {P <: AbstractPolynomial}
     zs = zeros(Int, k+1)
     zs[end] = 1
     P(zs, var)
 end
+basis(p::P, k::Int, _var::SymbolLike=:x; var=_var) where {P<:AbstractPolynomial} = basis(P, k, var)
+
+
+
+
 
 # iteration
 # iteration occurs over the basis polynomials
@@ -445,20 +452,20 @@ 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}, 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...)
+
 #=
 arithmetic =#
 Base.:-(p::P) where {P <: AbstractPolynomial} = P(-coeffs(p), p.var)
@@ -552,7 +559,8 @@ Base.:(==)(n::Number, p::AbstractPolynomial) = p == n
 function Base.isapprox(p1::AbstractPolynomial{T},
     p2::AbstractPolynomial{S};
     rtol::Real = (Base.rtoldefault(T, S, 0)),
-    atol::Real = 0,) where {T,S}
+                       atol::Real = 0,) where {T,S}
+    
     p1, p2 = promote(p1, p2)
     check_same_variable(p1, p2)  || error("p1 and p2 must have same var")
     p1t = truncate(p1; rtol = rtol, atol = atol)
@@ -561,6 +569,7 @@ function Base.isapprox(p1::AbstractPolynomial{T},
         return false
     end
     isapprox(coeffs(p1t), coeffs(p2t), rtol = rtol, atol = atol)
+    
 end
 
 function Base.isapprox(p1::AbstractPolynomial{T},

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)
 

src/polynomials/LaurentPolynomial.jl

@@ -158,8 +158,8 @@ Base.hash(p::LaurentPolynomial, h::UInt) = hash(p.var, hash(range(p), hash(coeff
 
 degree(p::LaurentPolynomial) = p.n[]
 isconstant(p::LaurentPolynomial) = range(p) == 0:0
-basis(P::Type{<:LaurentPolynomial{T}}, n::Int, var=:x) where{T} = LaurentPolynomial(ones(T,1), n:n, var)
-basis(P::Type{LaurentPolynomial}, n::Int, var=:x) = LaurentPolynomial(ones(Float64, 1), n:n, var)
+basis(P::Type{<:LaurentPolynomial{T}}, n::Int, var::SymbolLike=:x) where{T} = LaurentPolynomial(ones(T,1), n:n, var)
+basis(P::Type{LaurentPolynomial}, n::Int, var::SymbolLike=:x) = LaurentPolynomial(ones(Float64, 1), n:n, var)
 
 Base.zero(::Type{LaurentPolynomial{T}},  var=Symbollike=:x) where {T} =  LaurentPolynomial{T}(zeros(T,1),  0:0, Symbol(var))
 Base.zero(::Type{LaurentPolynomial},  var=Symbollike=:x) =  zero(LaurentPolynomial{Float64}, var)
@@ -259,7 +259,10 @@ function showterm(io::IO, ::Type{<:LaurentPolynomial}, pj::T, var, j, first::Boo
         printcoefficient(io, pj, j, mimetype)
     end
     printproductsign(io, pj, j, mimetype)
-    unicode_exponent(io, var, j)
+    iszero(j) && return
+    print(io, var)
+    j ==1  && return
+    unicode_exponent(io, j)
     return true
 end
 

src/polynomials/Poly.jl

@@ -38,6 +38,12 @@ Polynomials.@register Poly
 
 Base.convert(P::Type{<:Polynomial}, p::Poly{T}) where {T} = P(p.coeffs, p.var)
 
+Base.eltype(P::Type{<:Poly}) = P
+Base.zero(::Type{<:Poly{T}},var=:x)  where {T} = Poly{T}(zeros(T,0), var)
+Base.zero(::Type{<:Poly},var=:x)  where {T} = Poly(zeros(Float64,0), var)
+Base.one(::Type{<:Poly{T}},var=:x)  where {T} = Poly{T}(ones(T,1), var)
+Base.one(::Type{<:Poly},var=:x)  where {T} = Poly(ones(Float64,1), var)
+
 function (p::Poly{T})(x::S) where {T,S}
     oS = one(x)
     length(p) == 0 && return zero(T) *  oS
@@ -52,7 +58,7 @@ end
 function Base.:+(p1::Poly, p2::Poly)
     p1.var != p2.var && error("Polynomials must have same variable")
     n = max(length(p1), length(p2))
-    c = [p1[i] + p2[i] for i = 0:n]
+    c = [p1[i] + p2[i] for i = 0:n-1]
     return Poly(c, p1.var)
 end
 

src/polynomials/SparsePolynomial.jl

@@ -96,7 +96,7 @@ function isconstant(p::SparsePolynomial)
     return true
 end
 
-basis(P::Type{<:SparsePolynomial}, n::Int, var=:x) =
+basis(P::Type{<:SparsePolynomial}, n::Int, var::SymbolLike=:x) =
     SparsePolynomial(Dict(n=>one(eltype(one(P)))), var)
 
 # return coeffs as  a vector

src/polynomials/standard-basis.jl

@@ -1,6 +1,9 @@
 abstract type StandardBasisPolynomial{T} <: AbstractPolynomial{T} end
 
-const ⟒ = constructorof #\upin
+# We want  ⟒(P{α…,T}) = P{α…}
+# For StandardBasisPolynomials this is
+⟒(P::Type{<:StandardBasisPolynomial}) = constructorof(P)
+
 
 
 function showterm(io::IO, ::Type{<:StandardBasisPolynomial}, pj::T, var, j, first::Bool, mimetype) where {T} 
@@ -14,6 +17,7 @@ function showterm(io::IO, ::Type{<:StandardBasisPolynomial}, pj::T, var, j, firs
     return true
 end
 
+
 # allows  broadcast  issue #209
 evalpoly(x, p::StandardBasisPolynomial) = p(x)
 
@@ -25,6 +29,8 @@ isconstant(p::StandardBasisPolynomial) = degree(p) <= 0
 
 Base.convert(P::Type{<:StandardBasisPolynomial}, q::StandardBasisPolynomial) = isa(q, P) ? q : P([q[i] for i in 0:degree(q)], q.var)
 
+variable(::Type{P}, var::SymbolLike = :x) where {P <: StandardBasisPolynomial} = P([0, 1], var)
+
 function fromroots(P::Type{<:StandardBasisPolynomial}, r::AbstractVector{T}; var::SymbolLike = :x) where {T <: Number}
     n = length(r)
     c = zeros(T, n + 1)
@@ -45,9 +51,9 @@ function Base.:+(p::P, c::S) where {T, P <: StandardBasisPolynomial{T}, S<:Numbe
 end
 
 
-function derivative(p::P, order::Integer = 1) where {P <: StandardBasisPolynomial}
+function derivative(p::P, order::Integer = 1) where {T, P <: StandardBasisPolynomial{T}}
     order < 0 && error("Order of derivative must be non-negative")
-    T = eltype(p)
+
     # we avoid usage like Base.promote_op(*, T, Int) here, say, as
     # Base.promote_op(*, Rational, Int) is Any, not Rational in analogy to
     # Base.promote_op(*, Complex, Int)
@@ -66,8 +72,8 @@ function derivative(p::P, order::Integer = 1) where {P <: StandardBasisPolynomia
 end
 
 
-function integrate(p::P, k::S) where {P <: StandardBasisPolynomial, S<:Number}
-    T = eltype(p)
+function integrate(p::P, k::S) where {T, P <: StandardBasisPolynomial{T}, S<:Number}
+
     R = eltype((one(T)+one(S))/1)
     if hasnan(p) || isnan(k)
         return ⟒(P)([NaN])
@@ -82,7 +88,7 @@ function integrate(p::P, k::S) where {P <: StandardBasisPolynomial, S<:Number}
 end
 
 
-function Base.divrem(num::P, den::Q) where {P <: StandardBasisPolynomial, Q <: StandardBasisPolynomial}
+function Base.divrem(num::P, den::Q) where {T, P <: StandardBasisPolynomial{T}, S, Q <: StandardBasisPolynomial{S}}
 
     check_same_variable(num, den) || error("Polynomials must have same variable")
     var = num.var
@@ -94,7 +100,6 @@ function Base.divrem(num::P, den::Q) where {P <: StandardBasisPolynomial, Q <: S
     m == -1 && throw(DivideError())
     if m == 0 && den[0] ≈ 0 throw(DivideError()) end
 
-    T, S =  eltype(num), eltype(den)
     R = eltype(one(T)/one(S))
 
     deg = n - m + 1
@@ -120,13 +125,12 @@ function Base.divrem(num::P, den::Q) where {P <: StandardBasisPolynomial, Q <: S
 end
 
 
-function companion(p::P) where {P <: StandardBasisPolynomial}
+function companion(p::P) where {T, P <: StandardBasisPolynomial{T}}
     d = length(p) - 1
     d < 1 && error("Series must have degree greater than 1")
     d == 1 && return diagm(0 => [-p[0] / p[1]])
 
 
-    T = eltype(p)
     R = eltype(one(T)/one(T))
 
     comp = diagm(-1 => ones(R, d - 1))
@@ -137,8 +141,8 @@ function companion(p::P) where {P <: StandardBasisPolynomial}
     return comp
 end
 
-function  roots(p::P; kwargs...)  where  {P <: StandardBasisPolynomial}
-    T = eltype(p)
+function  roots(p::P; kwargs...)  where  {T, P <: StandardBasisPolynomial{T}}
+
     R = eltype(one(T)/one(T))    
     d = degree(p)
     if d < 1

src/show.jl

@@ -239,12 +239,16 @@ function printexponent(io, var, i, mimetype::MIME)
     end
 end
 
-function unicode_exponent(io, var, j)
-    iszero(j) && return
-    print(io, var)
-    j ==1  && return
+function unicode_exponent(io, j)
     a = ("⁻","","","⁰","¹","²","³","⁴","⁵","⁶","⁷","⁸","⁹")
     for i in string(j)
         print(io, a[Int(i)-44])
     end
 end
+
+function unicode_subscript(io, j)
+    a = ("⁻","","","₀","₁","₂","₃","₄","₅","₆","₇","₈","₉")
+    for i in string(j)
+        print(io, a[Int(i)-44])
+    end
+end