hastrig test to save simplification time

Co-authored-by: "Yingbo Ma" <[email protected]>

Author: shashi

src/rule_dsl.jl

@@ -266,8 +266,12 @@ end
 
 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)
+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

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