Merge pull request #93 from jverzani/constructor

Minor tweaks

Author: jverzani

REQUIRE

@@ -1,2 +1,2 @@
 julia 0.4
-Compat 0.7.15
+Compat 0.9.4

src/Polynomials.jl

@@ -75,6 +75,8 @@ immutable Poly{T}
 end
 
 Poly(n::Number, var::SymbolLike = :x) = Poly([n], var)
+@compat (::Type{Poly{T}}){T,S}(x::Vector{S}, var::SymbolLike = :x) =
+  Poly(convert(Vector{T}, x), var)
 
 # create a Poly object from its roots
 """
@@ -107,8 +109,9 @@ include("show.jl") # display polynomials.
 
 convert{T}(::Type{Poly{T}}, p::Poly{T}) = p
 convert{T}(::Type{Poly{T}}, p::Poly) = Poly(convert(Vector{T}, p.a), p.var)
-convert{T, S<:Number}(::Type{Poly{T}}, x::S) = Poly(promote_type(T, S)[x])
-convert{T, S<:Number,n}(::Type{Poly{T}}, x::Array{S,n}) = map(el->convert(Poly{promote_type(T,S)},el),x)
+convert{T, S<:Number}(::Type{Poly{T}}, x::S, var::SymbolLike=:x) = Poly(promote_type(T, S)[x], var)
+convert{T, S<:Number}(::Type{Poly{T}}, x::Vector{S}, var::SymbolLike=:x) = (R = promote_type(T,S); Poly(convert(Vector{R},x), var))
+convert{T, S<:Number,n}(::Type{Poly{T}}, x::Array{S,n}, var::SymbolLike=:x) = map(el->convert(Poly{promote_type(T,S)},el,var),x)
 promote_rule{T, S}(::Type{Poly{T}}, ::Type{Poly{S}}) = Poly{promote_type(T, S)}
 promote_rule{T, S<:Number}(::Type{Poly{T}}, ::Type{S}) = Poly{promote_type(T, S)}
 eltype{T}(::Poly{T}) = T
@@ -298,15 +301,20 @@ function *{T,S}(p1::Poly{T}, p2::Poly{S})
     Poly(a,p1.var)
 end
 
-## older . operators
-if VERSION < v"0.6.0-dev"
+## older . operators, hack to avoid warning on v0.6
+dot_operators = quote
     @compat Base.:.+{T<:Number}(c::T, p::Poly) = +(p, c)
     @compat Base.:.+{T<:Number}(p::Poly, c::T) = +(p, c)
     @compat Base.:.-{T<:Number}(p::Poly, c::T) = +(p, -c)
     @compat Base.:.-{T<:Number}(c::T, p::Poly) = +(p, -c)
     @compat Base.:.*{T<:Number,S}(c::T, p::Poly{S}) = Poly(c * p.a, p.var)
     @compat Base.:.*{T<:Number,S}(p::Poly{S}, c::T) = Poly(p.a * c, p.var)
 end
+VERSION < v"0.6.0-dev" && eval(dot_operators)
+
+
+# are any values NaN
+hasnan(p::Poly) = reduce(|, (@compat isnan.(p.a)))
 
 function divrem{T, S}(num::Poly{T}, den::Poly{S})
     if num.var != den.var
@@ -373,6 +381,7 @@ p(4)   # 57 = 1 + 2*4 + 3*4^2
 """
 function polyval{T,S}(p::Poly{T}, x::S)
     R = promote_type(T,S)
+
     lenp = length(p)
     if lenp == 0
         return zero(R) * x
@@ -407,20 +416,20 @@ polyint{T}(p::Poly{T}) = polyint(p, 0)
 
 # if we have coefficients that have `NaN` representation
 function polyint{T<:Union{Real,Complex},S<:Number}(p::Poly{T}, k::S)
-  any(map(isnan,p.a)) && return Poly(promote_type(T,S)[NaN])
-  _polyint(p, k)
+    hasnan(p) && return Poly(promote_type(T,S)[NaN])
+    _polyint(p, k)
 end
 
 # if we have initial condition that can represent `NaN`
 function polyint{T,S<:Union{Real,Complex}}(p::Poly{T}, k::S)
-  isnan(k) && return Poly(promote_type(T,S)[NaN])
-  _polyint(p, k)
+    isnan(k) && return Poly(promote_type(T,S)[NaN])
+    _polyint(p, k)
 end
 
 # if we have both coefficients and initial condition that can take `NaN`
 function polyint{T<:Union{Real,Complex},S<:Union{Real,Complex}}(p::Poly{T}, k::S)
-  (any(map(isnan,p.a)) || isnan(k)) && return Poly(promote_type(T,S)[NaN])
-  _polyint(p, k)
+    hasnan(p) || isnan(k) && return Poly(promote_type(T,S)[NaN])
+    _polyint(p, k)
 end
 
 # otherwise, catch all
@@ -450,12 +459,12 @@ polyder(Poly([1, 3, -1]))   # Poly(3 - 2x)
 """
 # if we have coefficients that can represent `NaN`s
 function polyder{T<:Union{Real,Complex}}(p::Poly{T}, order::Int=1)
-  n = length(p)
-  order < 0       && error("Order of derivative must be non-negative")
-  order == 0      && return p
-  any(map(isnan,p.a)) && return Poly(T[NaN], p.var)
-  n <= order      && return Poly(T[], p.var)
-  _polyder(p, order)
+    n = length(p)
+    order < 0       && error("Order of derivative must be non-negative")
+    order == 0      && return p
+    hasnan(p)       && return Poly(T[NaN], p.var)
+    n <= order      && return Poly(T[], p.var)
+    _polyder(p, order)
 end
 
 # otherwise
@@ -520,7 +529,7 @@ function roots{T}(p::Poly{T})
     companion = diagm(ones(R, n-1), -1)
     an = p[end-num_trailing_zeros]
     companion[1,:] = -p[(end-num_trailing_zeros-1):-1:num_leading_zeros] / an
-    
+
     D = eigvals(companion)
     r = zeros(eltype(D),length(p)-num_trailing_zeros-1)
     r[1:n] = D
@@ -541,7 +550,7 @@ gcd(poly([1,1,2]), poly([1,2,3])) # returns (x-1)*(x-2)
 ```
 """
 function gcd{T, S}(a::Poly{T}, b::Poly{S})
-    if all(map(abs,b.a).<=2*eps(S))
+    if reduce(&, (@compat abs.(b.a)) .<=2*eps(S))
         return a
     else
         s, r = divrem(a, b)

src/show.jl

@@ -94,7 +94,7 @@ end
 
 
 ## print the sign
-## returns aspos(pj) 
+## returns aspos(pj)
 function printsign{T}(io::IO, pj::T, j, first, mimetype)
     neg = isneg(pj)
     if first
@@ -111,12 +111,12 @@ function printproductsign{T}(io::IO, pj::T, j, mimetype)
     j == 0 && return
     (showone(T) || pj != one(T)) &&  print(io, showop(mimetype, "*"))
 end
-  
+
 function printcoefficient{T}(io::IO, pj::Complex{T}, j, mimetype)
 
-    hasreal = abs(real(pj)) > 0
-    hasimag = abs(imag(pj)) > 0
-    
+    hasreal = abs(real(pj)) > 0 || isnan(real(pj)) || isinf(real(pj))
+    hasimag = abs(imag(pj)) > 0 || isnan(imag(pj)) || isinf(imag(pj))
+
     if hasreal & hasimag
         print(io, '(')
         show(io, mimetype, pj)
@@ -127,14 +127,15 @@ function printcoefficient{T}(io::IO, pj::Complex{T}, j, mimetype)
     elseif hasimag
         b = imag(pj)
         (showone(T) || b != one(T)) && show(io,  mimetype, b)
+        (isnan(imag(pj)) || isinf(imag(pj))) && print(io, showop(mimetype, "*"))
         show(io, mimetype, im)
     else
         return
     end
 end
 
-  
-## show a single term 
+
+## show a single term
 function printcoefficient{T}(io::IO, pj::T, j, mimetype)
     pj == one(T) && !(showone(T) || j == 0) && return
     show(io, mimetype, pj)

test/runtests.jl

@@ -13,6 +13,10 @@ p5 = Poly([1,4,6,4,1,0,0,0,0,0,0,0,0,0,0,0,0,0])
 pN = Poly([276,3,87,15,24,0])
 pR = Poly([3//4, -2//1, 1//1])
 X = Poly([0.0, 1.0])
+T = Int64
+Poly{T}([zero(T), one(T)])
+Poly{T}([zero(T), one(T)], :y)
+
 p1000 = Poly(randn(1000))
 
 @test length(pNULL) == 1
@@ -231,6 +235,8 @@ p = Poly([1, im])
 @test repr(p) == "Poly(1 + im⋅x)"
 p = Poly([1+im, 1-im, -1+im, -1 - im])# minus signs
 @test repr(p) == "Poly((1 + 1im) + (1 - 1im)⋅x - (1 - 1im)⋅x^2 - (1 + 1im)⋅x^3)"
+p = Poly([1.0, 0 + NaN*im, NaN, Inf, 0 - Inf*im]) # handle NaN or Inf appropriately
+@test repr(p) == "Poly(1.0 + NaN⋅im⋅x + NaN⋅x^2 + Inf⋅x^3 - Inf⋅im⋅x^4)"
 
 p = Poly([1,2,3])
 @test reprmime("text/latex", p) == "\$1 + 2\\cdot x + 3\\cdot x^{2}\$"