Add element-wise operation support (closes #51)

Added .* .- .+ support between numbers and Polys. Added promotion
rule between Numbers and Polys. Added unit tests.

Author: neveritt

src/Polynomials.jl

@@ -12,7 +12,7 @@ export Pade, padeval
 export truncate!
 
 import Base: length, endof, getindex, setindex!, copy, zero, one, convert, norm, gcd
-import Base: show, print, *, /, //, -, +, ==, divrem, div, rem, eltype
+import Base: show, print, *, /, //, -, +, ==, divrem, div, rem, eltype, .*, .-, .+
 import Base: promote_rule, truncate, chop
 if VERSION >= v"0.4"
     import Base.call
@@ -111,6 +111,7 @@ 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)
 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
 
 """
@@ -212,11 +213,17 @@ one{T}(::Type{Poly{T}}) = Poly([one(T)])
 ## Overload arithmetic operators for polynomial operations between polynomials and scalars
 *{T<:Number,S}(c::T, p::Poly{S}) = Poly(c * p.a, p.var)
 *{T<:Number,S}(p::Poly{S}, c::T) = Poly(p.a * c, p.var)
+.*{T<:Number,S}(c::T, p::Poly{S}) = Poly(c * p.a, p.var)
+.*{T<:Number,S}(p::Poly{S}, c::T) = Poly(p.a * c, p.var)
 /(p::Poly, c::Number) = Poly(p.a / c, p.var)
 -(p::Poly) = Poly(-p.a, p.var)
--(p::Poly, c::Number) = +(p, -c)
-+(c::Number, p::Poly) = +(p, c)
-function +(p::Poly, c::Number)
+-{T<:Number}(p::Poly, c::T) = +(p, -c)
+.-{T<:Number}(p::Poly, c::T) = +(p, -c)
+.-{T<:Number}(c::T, p::Poly) = +(p, -c)
++{T<:Number}(c::T, p::Poly) = +(p, c)
+.+{T<:Number}(c::T, p::Poly) = +(p, c)
+.+{T<:Number}(p::Poly, c::T) = +(p, c)
+function +{T<:Number}(p::Poly, c::T)
     if length(p) < 1
         return Poly([c,], p.var)
     else
@@ -225,7 +232,7 @@ function +(p::Poly, c::Number)
         return p2;
     end
 end
-function -{T}(c::Number, p::Poly{T})
+function -{T<:Number}(c::T, p::Poly)
     if length(p) < 1
         return Poly(T[c,], p.var)
     else

test/runtests.jl

@@ -153,3 +153,17 @@ psum = p1 + p2 - p3
 @test truncate(Poly([2,1]),reltol=1/2,abstol=0) == Poly([2])
 @test truncate(Poly([2,1]),reltol=1,abstol=0)   == Poly([0])
 @test truncate(Poly([2,1]),reltol=0,abstol=1)   == Poly([2])
+
+## elementwise operations
+println("Test for element-wise operations")
+p1  = Poly([1, 2])
+p2  = Poly([3, 1.])
+p   = [p1, p2]
+q   = [3, p1]
+@test isa(q,Vector{Poly{Int64}})
+psum  = p+3
+pprod = p*3
+pmin  = p-3
+@test isa(psum, Vector{Poly{Float64}})
+@test isa(pprod,Vector{Poly{Float64}})
+@test isa(pmin, Vector{Poly{Float64}})