Merge pull request #73 from Keno/showfix

jverzani · web-flow · commit 9ce8287dc0c4 · 2016-11-13T20:22:22.000-05:00
Change show.jl to be more modular
diff --git a/src/Polynomials.jl b/src/Polynomials.jl
@@ -69,7 +69,7 @@ immutable Poly{T<:Number}
             return new(zeros(T,1), @compat Symbol(var))
         else
             # determine the last nonzero element and truncate a accordingly
-            a_last = max(1,findlast(a))
+            a_last = max(1,findlast(x->x!=zero(T), a))
             new(a[1:a_last], @compat Symbol(var))
         end
     end
@@ -93,7 +93,7 @@ poly([1,2,3])     # Poly(-6 + 11x - 6x^2 + x^3)
 function poly{T}(r::AbstractVector{T}, var=:x)
     n = length(r)
     c = zeros(T, n+1)
-    c[1] = 1
+    c[1] = one(T)
     for j = 1:n
         for i = j:-1:1
             c[i+1] = c[i+1]-r[j]*c[i]
@@ -148,15 +148,25 @@ Return the indeterminate of a polynomial, `x`.
 * `variable([var::Symbol])`: return polynomial 1x over `Float64`.
 
 """
-variable{T}(p::Poly{T}) = poly(zeros(T,1), p.var)
-variable{T<:Number}(::Type{T}, var=:x) = poly(zeros(T,1), var)
-variable(var::Symbol=:x) = poly([0.0], var)
+variable{T<:Number}(::Type{T}, var=:x) = Poly([zero(T), one(T)], var)
+variable{T}(p::Poly{T}) = variable(T, p.var)
+variable(var::Symbol=:x) = variable(Float64, var)
 
 """
 
 `truncate{T}(p::Poly{T}; reltol = eps(T), abstol = eps(T))`: returns a polynomial with coefficients a_i truncated to zero if |a_i| <= reltol*maxabs(a)+abstol
 
 """
+function truncate{T}(p::Poly{Complex{T}}; reltol = eps(T), abstol = eps(T))
+    a = coeffs(p)
+    amax = maxabs(a)
+    thresh = amax * reltol + abstol
+    anew = map(ai -> complex(abs(real(ai)) <= thresh ? zero(T) : real(ai),
+                             abs(imag(ai)) <= thresh ? zero(T) : imag(ai)),
+               a)
+    return Poly(anew, p.var)
+end
+
 function truncate{T}(p::Poly{T}; reltol = eps(T), abstol = eps(T))
     a = coeffs(p)
     amax = maxabs(a)
@@ -218,7 +228,9 @@ function setindex!(p::Poly, vs, idx::AbstractArray)
     [setindex!(p, v, i) for (i,v) in zip(idx, vs)]
     p
 end
+Base.eachindex{T}(p::Poly{T}) = 0:(length(p)-1)
 
+    
 copy(p::Poly) = Poly(copy(p.a), p.var)
 
 zero{T}(p::Poly{T}) = Poly([zero(T)], p.var)
@@ -229,6 +241,8 @@ 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)
+Base.dot{T<:Number,S}(p::Poly{S}, c::T) = p * c
+Base.dot{T<:Number,S}(c::T, p::Poly{S}) = c * p
 .*{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)
@@ -356,7 +370,7 @@ function polyval{T,S}(p::Poly{T}, x::S)
     if lenp == 0
         return zero(R) * x
     else
-        y = convert(R, p[end]) + 0*x
+        y = convert(R, p[end]) + zero(T)*x
         for i = (endof(p)-1):-1:0
             y = p[i] + x*y
         end
diff --git a/src/show.jl b/src/show.jl
@@ -1,82 +1,199 @@
+## Poly{T} is basically T[x], with T a Ring.
+## T[x] may not have an order so abs, comparing to 0 may not be defined.
 
-function show(io::IO, p::Poly)
-    print(io,"Poly(")
-    print(io,p)
-    print(io,")")
+## to handle this case we create some functions
+## which can be modified by users for other Ts
+
+"`hasneg(::T)` attribute is true if: `pj < zero(T)` is defined."
+hasneg{T}(::Type{T}) = false
+
+"Could value possibly be negative and if so, is it?"
+isneg{T}(pj::T) = hasneg(T) && pj < zero(T)
+
+"Make `pj` positive if it is negative. (Don't call `abs` as that may not be defined, or appropriate.)"
+aspos{T}(pj::T) = (hasneg(T) && isneg(pj)) ? -pj : pj
+
+"Should a value of `one(T)` be shown as a coefficient of monomial `x^i`, `i >= 1`? (`1.0x^2` is shown, `1 x^2` is not)"
+showone{T}(::Type{T}) = true
+
+
+#####
+
+## Numbers
+hasneg{T<:Real}(::Type{T}) = true
+
+### Integer
+showone{T<:Integer}(::Type{T}) = false
+showone{T}(::Type{Rational{T}}) = false
+
+
+
+
+### Complex coefficients
+hasneg{T}(::Type{Complex{T}}) = true      ## we say neg if real(z) < 0 || real(z) == 0 and imag(g) < 0
+
+function isneg{T}(pj::Complex{T})
+    real(pj) < 0 && return true
+    (real(pj) == 0 && imag(pj) < 0) && return(true)
+    return false
 end
 
-function printexponent(io,var,i)
-    if i == 0
-    elseif i == 1
-        print(io,var)
-    else
-        print(io,var,"^",i)
+showone{T}(pj::Type{Complex{T}}) = showone(T)
+
+
+### Polynomials as coefficients
+hasneg{S}(::Type{Poly{S}}) = false
+showone{S}(::Type{Poly{S}}) = false
+
+
+#####
+
+"Show different operations depending on mimetype. `l-` is leading minus sign."
+function showop(::MIME"text/plain", op)
+    d = Dict("*" => "⋅", "+" => " + ", "-" => " - ", "l-" => "-")
+    d[op]
+end
+
+function showop(::MIME"text/latex", op)
+    d = Dict("*" => "\\cdot ", "+" => " + ", "-" => " - ", "l-" => "-")
+    d[op]
+end
+
+function showop(::MIME"text/html", op)
+    d = Dict("*" => "&#8729;", "+" => " &#43; ", "-" => " &#45; ", "l-" => "&#45;")
+    d[op]
+end
+
+
+
+###
+
+function printpoly{T}(io::IO, p::Poly{T}, mimetype)
+    first = true
+    printed_anything = false
+    for i in eachindex(p)
+        printed = showterm(io,p,i,first, mimetype)
+        first &= !printed
+        printed_anything |= printed
     end
+    printed_anything || print(io, zero(T))
 end
 
-function printterm{T}(io::IO,p::Poly{T},j,first)
+function showterm{T}(io::IO,p::Poly{T},j,first, mimetype)
     pj = p[j]
-    if pj == zero(T)
-        return false
-    end
-    neg = pj < zero(T)
-    if first
-        neg && print(io, "-")    #Prepend - if first and negative
-    else
-        neg ? print(io, " - ") : print(io," + ")
-    end
-    pj = abs(pj)
-    if pj != one(T) || j == 0
-        show(io,pj)
-    end
-    printexponent(io,p.var,j)
+
+    pj == zero(T) && return false
+
+    pj = printsign(io, pj, j, first, mimetype)
+    printcoefficient(io, pj, j, mimetype)
+    printproductsign(io, pj, j, mimetype)
+    printexponent(io,p.var,j, mimetype)
     true
 end
 
-function printterm{T<:Complex}(io::IO,p::Poly{T},j,first)
-    pj = p[j]
-    abs_repj = abs(real(pj))
-    abs_impj = abs(imag(pj))
-    if abs_repj < 2*eps(T) && abs_impj < 2*eps(T)
-        return false
-    end
 
-    # We show a negative sign either for any complex number with negative
-    # real part (and then negate the immaginary part) of for complex
-    # numbers that are pure imaginary with negative imaginary part
-    
-    neg = ((abs_repj > 2*eps(T)) && real(pj) < 0) ||
-            ((abs_impj > 2*eps(T)) && imag(pj) < 0)
 
+## print the sign
+## returns aspos(pj) 
+function printsign{T}(io::IO, pj::T, j, first, mimetype)
+    neg = isneg(pj)
     if first
-        neg && print(io, "-")    #Prepend - if first and negative
+        neg && print(io, showop(mimetype, "l-"))    #Prepend - if first and negative
     else
-        neg ? print(io," - ") : print(io," + ")
+        neg ? print(io, showop(mimetype, "-")) : print(io,showop(mimetype, "+"))
     end
+
+    aspos(pj)
+end
+
+## print * or cdot, ...
+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
     
-    if abs_repj > 2*eps(T)    #Real part is not 0
-        if abs_impj > 2*eps(T)    #Imag part is not 0
-            print(io,'(',neg ? -pj : pj,')')
-        else
-            print(io, neg ? -real(pj) : real(pj))
-        end
+    if hasreal & hasimag
+        print(io, '(')
+        show(io, mimetype, pj)
+        print(io, ')')
+    elseif hasreal
+        a = real(pj)
+        (showone(T) || a != one(T)) && show(io, mimetype, a)
+    elseif hasimag
+        b = imag(pj)
+        (showone(T) || b != one(T)) && show(io,  mimetype, b)
+        show(io, mimetype, im)
     else
-        if abs_impj > 2*eps(T)
-            print(io,'(', abs(imag(pj)),"im)")
-        end
+        return
     end
-    printexponent(io,p.var,j)
-    true
 end
 
-function print{T}(io::IO, p::Poly{T})
-    first = true
-    printed_anything = false
-    n = length(p)-1
-    for i = 0:n
-        printed = printterm(io,p,i,first)
-        first &= !printed
-        printed_anything |= printed
+  
+## 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)
+end
+
+## show exponent
+function printexponent(io,var,i, mimetype::MIME"text/latex")
+    if i == 0
+        return
+    elseif i == 1
+        print(io,var)
+    else
+        print(io,var,"^{$i}")
+    end
+end
+
+function printexponent(io,var,i, mimetype)
+    if i == 0
+        return
+    elseif i == 1
+        print(io,var)
+    else
+        print(io,var,"^",i)
     end
-    printed_anything || print(io,zero(T))
+end
+
+
+####
+
+## text/plain
+@compat Base.show{T}(io::IO, p::Poly{T}) = show(io, MIME("text/plain"), p)
+@compat function Base.show{T}(io::IO, mimetype::MIME"text/plain", p::Poly{T})
+    print(io,"Poly(")
+    printpoly(io, p, mimetype)
+    print(io,")")
+
+end
+
+## text/latex
+@compat function Base.show{T}(io::IO, mimetype::MIME"text/latex", p::Poly{T})
+    print(io, "\$")
+    printpoly(io, p, mimetype)
+    print(io, "\$")
+end
+
+@compat function Base.show{T}(io::IO, mimetype::MIME"text/latex", a::Rational{T})
+    abs(a.den) == one(T) ? print(io, a.num) : print(io, "\\frac{$(a.num)}{$(a.den)}")
+end
+
+@compat function Base.show{T<:Number}(io::IO, mimetype::MIME"text/latex", a::T)
+    print(io, a)
+end
+
+
+## text/html
+@compat function Base.show{T}(io::IO, mimetype::MIME"text/html", p::Poly{T})
+    printpoly(io, p, mimetype)
+end
+
+@compat function Base.show{T<:Number}(io::IO, mimetype::MIME"text/html", a::T)
+    print(io, a)
 end
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -184,7 +184,6 @@ p1 = Poly([4,5,6])
 p1[0:1] = [7,8]
 @test all(p1[0:end] .== [7,8,6])
 
-
 ## conjugate of poly (issue #59)
 as = [im, 1, 2]
 bs = [1, 1, 2]
@@ -197,8 +196,53 @@ p2 = convert(Poly{Int64}, p1)
 p2[3] = 3
 @test p1[3] == 3
 
+
 ## eltype of a Poly type
 types = [Int, UInt8, Float64]
 for t in types
   @test t == eltype(Poly{t})
 end
+
+## Polynomials with non-Real type
+import Base: +, *, -
+immutable Mod2 <: Number
+  v::Bool
+end
++(x::Mod2,y::Mod2) = Mod2(x.v$y.v)
+*(x::Mod2,y::Mod2) = Mod2(x.v&y.v)
+-(x::Mod2,y::Mod2) = x+y
+-(x::Mod2) = x
+Base.one(::Type{Mod2}) = Mod2(true)
+Base.zero(::Type{Mod2}) = Mod2(false)
+Base.convert(::Type{Mod2},x::Integer) = Mod2(convert(Bool,x))
+Base.convert(::Type{Bool},x::Mod2) = x.v
+
+# Test that none of this throws
+p = Poly([Mod2(true),Mod2(false), Mod2(true)])
+repr(p)
+@test p(Mod2(false)) == p[0]
+
+
+## changes to show
+p = Poly([1,2,3,1])  # leading coefficient of 1
+@test repr(p) == "Poly(1 + 2⋅x + 3⋅x^2 + x^3)"
+p = Poly([1.0, 2.0, 3.0, 1.0])
+@test repr(p) == "Poly(1.0 + 2.0⋅x + 3.0⋅x^2 + 1.0⋅x^3)"
+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,2,3])
+@test reprmime("text/latex", p) == "\$1 + 2\\cdot x + 3\\cdot x^{2}\$"
+p = Poly([1//2, 2//3, 1])
+@test reprmime("text/latex", p) == "\$\\frac{1}{2} + \\frac{2}{3}\\cdot x + x^{2}\$"
+
+
+## want to be able to copy and paste
+string_eval_poly(p,x) = eval(Expr(:function, Expr(:call, :f, :x), parse(string(p)[6:end-1])))(x)
+p = Poly([1,2,3]) # copy and paste
+q = Poly([1//1, 2//1, 3//1])
+r = Poly([1.0, 2, 3])
+@test string_eval_poly(p, 5) == p(5)
+@test string_eval_poly(q, 5) == q(5)
+@test string_eval_poly(r, 5) == r(5)
+    
