Merge pull request #185 from JuliaSymbolics/s/printing-update

Some printing improvements

Author: shashi

src/abstractalgebra.jl

@@ -23,7 +23,7 @@ function labels!(dicts, t)
         return t
     elseif istree(t) && (operation(t) == (*) || operation(t) == (+) || operation(t) == (-))
         tt = arguments(t)
-        return similarterm(t, operation(t), map(x->labels!(dicts, x), arguments(t)))
+        return similarterm(t, operation(t), map(x->labels!(dicts, x), tt))
     elseif istree(t) && operation(t) == (^) && length(arguments(t)) > 1 && isnonnegint(arguments(t)[2])
         return similarterm(t, operation(t), map(x->labels!(dicts, x), arguments(t)))
     else

src/types.jl

@@ -347,58 +347,112 @@ const show_simplified = Ref(false)
 
 Base.show(io::IO, t::Term) = show_term(io, t)
 
-function show_term(io::IO, t)
-    if get(io, :simplify, show_simplified[])
-        s = simplify(t)
+isnegative(t::Real) = t < 0
+function isnegative(t)
+    if istree(t) && operation(t) === (*)
+        coeff = first(arguments(t))
+        return isnegative(coeff)
+    end
+    return false
+end
+
+setargs(t, args) = Term{symtype(t)}(operation(t), args)
+cdrargs(args) = setargs(t, cdr(args))
 
-        Base.print(IOContext(io, :simplify=>false), s)
+print_arg(io, x::Union{Complex, Rational}) = print(io, "(", x, ")")
+print_arg(io, x) = print(io, x)
+print_arg(io, f::typeof(^), x) = print_arg(IOContext(io, :paren=>true), x)
+function print_arg(io, f, x)
+    f !== (*) && return print_arg(io, x)
+    if istree(x) && Base.isbinaryoperator(nameof(operation(x)))
+        print_arg(IOContext(io, :paren=>true), x)
     else
-        f = operation(t)
-        args = arguments(t)
-        fname = nameof(f)
-        binary = Base.isbinaryoperator(fname)
-        if binary
-            get(io, :paren, false) && Base.print(io, "(")
-            for i = 1:length(args)
-                length(args) == 1 && Base.print(io, fname)
-
-                paren_scalar = args[i] isa Complex || args[i] isa Rational
-
-                paren_scalar && Base.print(io, "(")
-                # Do not put parenthesis if it's a multiplication and not args
-                # of power
-                paren = !(istree(args[i]) && operation(args[i]) == (*)) || fname === :^
-                Base.print(IOContext(io, :paren => paren), args[i])
-                paren_scalar && Base.print(io, ")")
-
-                if i != length(args)
-                    if fname == :*
-                        if i == 1 && args[1] isa Number && !(args[2] isa Number) && !paren_scalar
-                            # skip
-                            # do not show * if it's a scalar times something
-                        else
-                            Base.print(io, "*")
-                        end
-                    else
-                        Base.print(io, fname == :^ ? '^' : " $fname ")
-                    end
-                end
-            end
-            get(io, :paren, false) && Base.print(io, ")")
+        print_arg(io, x)
+    end
+end
+
+function show_add(io, args)
+    negs = filter(isnegative, args)
+    nnegs = filter(!isnegative, args)
+    for (i, t) in enumerate(nnegs)
+        i != 1 && print(io, " + ")
+        print_arg(io, +,  t)
+    end
+
+    for (i, t) in enumerate(negs)
+        if i==1 && isempty(nnegs)
+            print_arg(io, -, t)
         else
-            if f isa Sym
-                Base.print(io, nameof(f))
+            print(io, " - ")
+            print_arg(io, +, -t)
+        end
+    end
+end
+
+function show_mul(io, args)
+    length(args) == 1 && return print_arg(io, *, args[1])
+
+    paren_scalar = args[1] isa Complex || args[1] isa Rational
+    minus = args[1] isa Number && args[1] == -1
+    unit = args[1] isa Number && args[1] == 1
+    nostar = !paren_scalar && args[1] isa Number && !(args[2] isa Number)
+    for (i, t) in enumerate(args)
+        if i != 1
+            if i==2 && nostar
             else
-                Base.show(io, f)
-            end
-            Base.print(io, "(")
-            for i=1:length(args)
-                Base.print(IOContext(io, :paren => false), args[i])
-                i != length(args) && Base.print(io, ", ")
+                print(io, "*")
             end
-            Base.print(io, ")")
+        end
+        if i == 1 && minus
+            print(io, "-")
+        elseif i == 1 && unit
+        else
+            print_arg(io, *, t)
         end
     end
+end
+
+function show_call(io, f, args)
+    fname = nameof(f)
+    binary = Base.isbinaryoperator(fname)
+    if binary
+        for (i, t) in enumerate(args)
+            i != 1 && print(io, fname == :^ ? fname : " $fname ")
+            print_arg(io, (^), t)
+        end
+    else
+        if f isa Sym
+            Base.show_unquoted(io, nameof(f))
+        else
+            Base.show(io, f)
+        end
+        print(io, "(")
+        for i=1:length(args)
+            print(IOContext(io, :paren => false), args[i])
+            i != length(args) && print(io, ", ")
+        end
+        print(io, ")")
+    end
+end
+
+function show_term(io::IO, t)
+    if get(io, :simplify, show_simplified[])
+        return print(IOContext(io, :simplify=>false), simplify(t))
+    end
+
+    f = operation(t)
+    args = arguments(t)
+
+    get(io, :paren, false) && print(io, "(")
+    if f === (+)
+        show_add(io, args)
+    elseif f === (*)
+        show_mul(io, args)
+    else
+        show_call(io, f, args)
+    end
+    get(io, :paren, false) && print(io, ")")
+
     return nothing
 end
 

test/basics.jl

@@ -102,14 +102,15 @@ end
 @testset "printing" begin
     @syms a b c
     @test repr(a+b) == "a + b"
-    @test repr(-a) == "-1a"
-    @test repr(-a + 3) == "3 + -1a"
-    @test repr(-(a + b)) == "-1a + -1b"
+    @test repr(-a) == "-a"
+    @test repr(-a + 3) == "3 - a"
+    @test repr(-(a + b)) == "-a - b"
     @test repr((2a)^(-2a)) == "(2a)^(-2a)"
     @test repr(1/2a) == "(1//2)*(a^-1)"
     @test repr(2/(2*a)) == "a^-1"
-    @test repr(Term(*, [1, 1])) == "1*1"
-    @test repr((a + b) - (b + c)) == "a + -1c"
+    @test repr(Term(*, [1, 1])) == "*1"
+    @test repr(Term(*, [2, 1])) == "2*1"
+    @test repr((a + b) - (b + c)) == "a - c"
 end
 
 toterm(t) = Term{symtype(t)}(operation(t), arguments(t))