Merge pull request #102 from JuliaSymbolics/s/hastrig

Check if an expression has trigonometric functions and use a different ruleset

Author: YingboMa

src/rule_dsl.jl

@@ -264,8 +264,14 @@ function _recurse_apply_ruleset_threaded(r::RuleSet, term, context; depth, threa
     Term{symtype(term)}(operation(term), args)
 end
 
-function (r::RuleSet)(term, context=EmptyCtx();  depth=typemax(Int), applyall::Bool=false, recurse::Bool=true,
-                      threaded::Bool=false, thread_subtree_cutoff::Int=100)
+const rule_repr = IdDict()
+
+function (r::RuleSet)(term, context=EmptyCtx();
+                      depth=typemax(Int),
+                      applyall::Bool=false,
+                      recurse::Bool=true,
+                      threaded::Bool=false,
+                      thread_subtree_cutoff::Int=100)
     rules = r.rules
     term = to_symbolic(term)
     # simplify the subexpressions
@@ -286,7 +292,7 @@ function (r::RuleSet)(term, context=EmptyCtx();  depth=typemax(Int), applyall::B
         end
         for i in 1:length(rules)
             expr′ = try
-                @timer(repr(rules[i]), rules[i](expr, context))
+                @timer(Base.@get!(rule_repr, rules[i], repr(rules[i])), rules[i](expr, context))
             catch err
                 throw(RuleRewriteError(rules[i], expr))
             end

src/rulesets.jl

@@ -4,12 +4,17 @@ const SIMPLIFY_RULES = RuleSet([
     @rule ~t::sym_isa(Number) => NUMBER_RULES(~t, applyall=true, recurse=true)
 ])
 
+const SIMPLIFY_RULES_TRIG = RuleSet([
+    @rule ~t::sym_isa(Bool)   => BOOLEAN_RULES(~t, applyall=true, recurse=true)
+    @rule ~t::sym_isa(Number) => NUMBER_RULES(~t, applyall=true, recurse=true)
+    @rule ~t::sym_isa(Number) => TRIG_RULES(~t, recurse=true)
+])
+
 const NUMBER_RULES = RuleSet([
     @rule ~t               => ASSORTED_RULES(~t, recurse=false)
     @rule ~t::is_operation(+) =>  PLUS_RULES(~t, recurse=false)
     @rule ~t::is_operation(*) => TIMES_RULES(~t, recurse=false)
     @rule ~t::is_operation(^) =>   POW_RULES(~t, recurse=false)
-    @rule ~t                  =>  TRIG_RULES(~t, recurse=false)
 ])
 
 const PLUS_RULES = RuleSet([

src/simplify.jl

@@ -11,6 +11,12 @@ of symtype Number.
 """
 default_rules(x, ctx) = SIMPLIFY_RULES
 
+function default_rules(x, ctx::EmptyCtx)
+    has_trig(x) ?
+        SIMPLIFY_RULES_TRIG :
+        SIMPLIFY_RULES
+end
+
 """
     simplify(x, ctx=EmptyCtx();
         rules=default_rules(x, ctx),

src/util.jl

@@ -34,3 +34,14 @@ drop_n(ll, n) = n === 0 ? ll : drop_n(cdr(ll), n-1)
 @inline drop_n(ll::AbstractArray, n) = drop_n(LL(ll, 1), n)
 @inline drop_n(ll::LL, n) = LL(ll.v, ll.i+n)
 
+has_trig(x) = false
+function has_trig(term::Term)
+    fns = (sin, cos, tan, cot, sec, csc)
+    op = operation(term)
+
+    if Base.@nany 6 i->fns[i] === op
+        return true
+    else
+        return any(has_trig, arguments(term))
+    end
+end