Merge branch 'master' into s/cse

Author: YingboMa

Project.toml

@@ -1,7 +1,7 @@
 name = "SymbolicUtils"
 uuid = "d1185830-fcd6-423d-90d6-eec64667417b"
 authors = ["Shashi Gowda"]
-version = "0.16.0"
+version = "0.17.0"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"

src/SymbolicUtils.jl

@@ -35,7 +35,7 @@ include("rewriters.jl")
 using .Rewriters
 
 using Combinatorics: permutations, combinations
-export @rule, @acrule, RuleSet, @capture
+export @rule, @acrule, RuleSet
 
 # Rule type and @rule macro
 include("rule.jl")

src/code.jl

@@ -100,6 +100,22 @@ toexpr(a::Assignment, st) = :($(toexpr(a.lhs, st)) = $(toexpr(a.rhs, st)))
 
 function_to_expr(op, args, st) = nothing
 
+function function_to_expr(op::Union{typeof(*),typeof(+)}, O, st)
+    out = get(st.symbolify, O, nothing)
+    out === nothing || return out
+    args = map(Base.Fix2(toexpr, st), arguments(O))
+    if length(args) >= 3 && symtype(O) <: Number
+        x, xs = Iterators.peel(args)
+        foldl(xs, init=x) do a, b
+            Expr(:call, op, a, b)
+        end
+    else
+        expr = Expr(:call, op)
+        append!(expr.args, args)
+        expr
+    end
+end
+
 function function_to_expr(::typeof(^), O, st)
     args = arguments(O)
     if length(args) == 2 && args[2] isa Real && args[2] < 0

src/simplify_rules.jl

@@ -56,7 +56,7 @@ let
         @rule(ifelse(~x::is_literal_number, ~y, ~z) => ~x ? ~y : ~z)
     ]
 
-    TRIG_RULES = [
+    TRIG_EXP_RULES = [
         @acrule(sin(~x)^2 + cos(~x)^2 => one(~x))
         @acrule(sin(~x)^2 + -1        => cos(~x)^2)
         @acrule(cos(~x)^2 + -1        => sin(~x)^2)
@@ -68,6 +68,9 @@ let
         @acrule(cot(~x)^2 + -1*csc(~x)^2 => one(~x))
         @acrule(cot(~x)^2 +  1 => csc(~x)^2)
         @acrule(csc(~x)^2 + -1 => cot(~x)^2)
+
+        @acrule(exp(~x) * exp(~y) => _iszero(~x + ~y) ? 1 : exp(~x + ~y))
+        @rule(exp(~x)^(~y) => exp(~x * ~y))
     ]
 
     BOOLEAN_RULES = [
@@ -112,7 +115,7 @@ let
         rule_tree
     end
 
-    trig_simplifier(;kw...) = Chain(TRIG_RULES)
+    trig_exp_simplifier(;kw...) = Chain(TRIG_EXP_RULES)
 
     bool_simplifier() = Chain(BOOLEAN_RULES)
 
@@ -123,10 +126,10 @@ let
     global serial_expand_simplifier
 
     function default_simplifier(; kw...)
-        IfElse(has_trig,
+        IfElse(has_trig_exp,
                Postwalk(IfElse(x->symtype(x) <: Number,
                                Chain((number_simplifier(),
-                                      trig_simplifier())),
+                                      trig_exp_simplifier())),
                                If(x->symtype(x) <: Bool,
                                   bool_simplifier()))
                         ; kw...),

src/utils.jl

@@ -77,15 +77,15 @@ pow(x, y::Symbolic) = Base.:^(x,y)
 pow(x::Symbolic,y::Symbolic) = Base.:^(x,y)
 
 # Simplification utilities
-function has_trig(term)
+function has_trig_exp(term)
     !istree(term) && return false
-    fns = (sin, cos, tan, cot, sec, csc)
+    fns = (sin, cos, tan, cot, sec, csc, exp)
     op = operation(term)
 
-    if Base.@nany 6 i->fns[i] === op
+    if Base.@nany 7 i->fns[i] === op
         return true
     else
-        return any(has_trig, arguments(term))
+        return any(has_trig_exp, arguments(term))
     end
 end
 

test/code.jl

@@ -13,15 +13,17 @@ test_repr(a, b) = @test repr(Base.remove_linenums!(a)) == repr(Base.remove_linen
     @test toexpr(Assignment(a, b)) == :(a = b)
     @test toexpr(a ← b) == :(a = b)
     @test toexpr(a+b) == :($(+)(a, b))
+    @test toexpr(a*b*c*d*e) == :($(*)($(*)($(*)($(*)(a, b), c), d), e))
+    @test toexpr(a+b+c+d+e) == :($(+)($(+)($(+)($(+)(a, b), c), d), e))
     @test toexpr(a+b) == :($(+)(a, b))
     @test toexpr(a^b) == :($(^)(a, b))
     @test toexpr(a^2) == :($(^)(a, 2))
     @test toexpr(a^-2) == :($(^)($(inv)(a), 2))
     @test toexpr(x(t)+y(t)) == :($(+)(x(t), y(t)))
-    @test toexpr(x(t)+y(t)+x(t+1)) == :($(+)(x(t), y(t), x($(+)(1, t))))
+    @test toexpr(x(t)+y(t)+x(t+1)) == :($(+)($(+)(x(t), y(t)), x($(+)(1, t))))
     s = LazyState()
     Code.union_symbolify!(s.symbolify, [x(t), y(t)])
-    @test toexpr(x(t)+y(t)+x(t+1), s) == :($(+)(var"x(t)", var"y(t)", x($(+)(1, t))))
+    @test toexpr(x(t)+y(t)+x(t+1), s) == :($(+)($(+)(var"x(t)", var"y(t)"), x($(+)(1, t))))
 
     ex = :(let a = 3, b = $(+)(1,a)
                $(+)(a, b)
@@ -35,14 +37,14 @@ test_repr(a, b) = @test repr(Base.remove_linenums!(a)) == repr(Base.remove_linen
 
     test_repr(toexpr(Func([x(t), x],[b ← a+2, y(t) ← b], x(t)+x(t+1)+b+y(t))),
               :(function (var"x(t)", x; b = $(+)(2, a), var"y(t)" = b)
-                    $(+)(b, var"x(t)", var"y(t)", x($(+)(1, t)))
+                    $(+)($(+)($(+)(b, var"x(t)"), var"y(t)"), x($(+)(1, t)))
                 end))
     test_repr(toexpr(Func([DestructuredArgs([x, x(t)], :state),
                            DestructuredArgs((a, b), :params)], [],
                           x(t+1) + x(t) + a  + b)),
               :(function (state, params)
                     let x = state[1], var"x(t)" = state[2], a = params[1], b = params[2]
-                        $(+)(a, b, var"x(t)", x($(+)(1, t)))
+                        $(+)($(+)($(+)(a, b), var"x(t)"), x($(+)(1, t)))
                     end
                 end))
 
@@ -81,7 +83,7 @@ test_repr(a, b) = @test repr(Base.remove_linenums!(a)) == repr(Base.remove_linen
               :(let foo = Any[3, 3, [1, 4]],
                     var"x(t)" = foo[1], b = foo[2], c = foo[3],
                     p = c[1], q = c[2]
-                    $(+)(a, b, c, var"x(t)")
+                    $(+)($(+)($(+)(a, b), c), var"x(t)")
                 end))
 
     test_repr(toexpr(Func([DestructuredArgs([a,b],c,inds=[:a, :b])], [],
@@ -119,7 +121,7 @@ test_repr(a, b) = @test repr(Base.remove_linenums!(a)) == repr(Base.remove_linen
 
     @test eval(toexpr(Let([a ← 1, b ← 2, arr ← @SLVector((:a, :b))(@SVector[1,2])],
                           MakeArray([a+b,a/b], arr)))) === @SLVector((:a, :b))(@SVector [3, 1/2])
-    
+
     R1 = eval(toexpr(Let([a ← 1, b ← 2, arr ← @MVector([1,2])],MakeArray([a,b,a+b,a/b], arr))))
     @test R1 == (@MVector [1, 2, 3, 1/2]) && R1 isa MVector
 
@@ -166,4 +168,3 @@ test_repr(a, b) = @test repr(Base.remove_linenums!(a)) == repr(Base.remove_linen
         @test f(2) == 2
     end
 end
-

test/rewrite.jl

@@ -43,7 +43,10 @@ end
     @eqtest @rule(+(~~x,~y,~~x) => (~~x, ~y, ~~x))(term(+,6,type=Any)) == ([], 6, [])
 end
 
+using SymbolicUtils: @capture
+
 @testset "Capture form" begin
+
     ex = a^a
 
     #note that @test inserts a soft local scope (try-catch) that would gobble
@@ -72,4 +75,4 @@ end
 
     @eqtest f(b^b) == b
     @test f(b+b) == nothing
-end
+end

test/rulesets.jl

@@ -88,6 +88,15 @@ end
     @eqtest simplify(1 + y + cot(x)^2) == csc(x)^2 + y
 end
 
+@testset "Exponentials" begin
+    @syms a::Real b::Real
+    @eqtest simplify(exp(a)*exp(b)) == simplify(exp(a+b))
+    @eqtest simplify(exp(a)*exp(a)) == simplify(exp(2a))
+    @test simplify(exp(a)*exp(-a)) == 1
+    @eqtest simplify(exp(a)^2) == simplify(exp(2a))
+    @eqtest simplify(exp(a) * a * exp(b)) == simplify(a*exp(a+b))
+end
+
 @testset "Depth" begin
     @syms x
     R = Rewriters.Postwalk(Rewriters.Chain([@rule(sin(~x) => cos(~x)),