Merge pull request #353 from JuliaSymbolics/s/frac-perf

speed up `flatten_fraction`

Author: shashi

benchmark/benchmarks.jl

@@ -66,4 +66,22 @@ let r = @rule(~x => ~x), rs = RuleSet([r]),
     overhead["substitute"]["a,b,c"] = @benchmarkable substitute(subs_expr, $(Dict(a=>1, b=>2, c=>3))) setup=begin
         subs_expr = (sin(a+b) + cos(b+c)) * (sin(b+c) + cos(c+a)) * (sin(c+a) + cos(a+b))
     end
+
+
+end
+
+let
+    pform = SUITE["polyform"]  = BenchmarkGroup()
+    @syms a b c d e f g h i
+    ex = (f + ((((g*(c^2)*(e^2)) / d - e*h*(c^2)) / b + (-c*e*f*g) / d + c*e*i) /
+              (i + ((c*e*g) / d - c*h) / b + (-f*g) / d) - c*e) / b +
+         ((g*(f^2)) / d + ((-c*e*f*g) / d + c*f*h) / b - f*i) /
+         (i + ((c*e*g) / d - c*h) / b + (-f*g) / d)) / d
+
+    o = (d + (e*((c*(g + (-d*g) / d)) / (i + (-c*(h + (-e*g) / d)) / b + (-f*g) / d))) / b +
+         (-f*(g + (-d*g) / d)) / (i + (-c*(h + (-e*g) / d)) / b + (-f*g) / d)) / d
+    pform["simplify_fractions"] = @benchmarkable simplify_fractions($ex)
+    pform["iszero"] = @benchmarkable SymbolicUtils.fraction_iszero($ex)
+    pform["isone"] = @benchmarkable SymbolicUtils.fraction_isone($o)
+    pform["easy_iszero"] = @benchmarkable SymbolicUtils.fraction_iszero($((b*(h + (-e*g) / d)) / b + (e*g) / d - h))
 end

src/polyform.jl

@@ -257,12 +257,10 @@ function simplify_div(d::Div)
     end
 end
 
-function add_divs(x, y)
-    x_num, x_den = polyform_factors(x, get_pvar2sym(), get_sym2term())
-    y_num, y_den = polyform_factors(y, get_pvar2sym(), get_sym2term())
-
-    (_mul(x_num, y_den) + _mul(x_den, y_num)) / (_mul(x_den, y_den))
-end
+add_divs(x::Div, y::Div) = (x.num * y.den + y.num * x.den) / (x.den * y.den)
+add_divs(x::Div, y) = (x.num + y * x.den) / x.den
+add_divs(x, y::Div) = (x * y.den + y.num) / y.den
+add_divs(x, y) = x + y
 
 """
     simplify_fractions(x)
@@ -275,14 +273,22 @@ function simplify_fractions(x)
 
     !needs_div_rules(x) && return x
 
-    isdiv(x) = x isa Div
-
-    rules = [@rule ~x::isdiv => simplify_div(~x)
-             @acrule ~a::isdiv + ~b::isdiv => add_divs(~a,~b)]
+    sdiv(a) = a isa Div ? simplify_div(a) : a
 
-    Fixpoint(Postwalk(RestartedChain(rules)))(x)
+    Postwalk(sdiv ∘ quick_cancel)(Postwalk(add_with_div)(x))
 end
 
+function add_with_div(x, flatten=true)
+    (!istree(x) || operation(x) != (+)) && return x
+    aa = unsorted_arguments(x)
+    !any(a->a isa Div, aa) && return x # no rewrite necessary
+
+    divs = filter(a->a isa Div, aa)
+    nondivs = filter(a->!(a isa Div), aa)
+    nds = isempty(nondivs) ? 0 : +(nondivs...)
+    d = reduce(quick_cancel∘add_divs, divs)
+    flatten ? quick_cancel(add_divs(d, nds)) : d + nds
+end
 """
     flatten_fractions(x)
 
@@ -294,17 +300,15 @@ julia> flatten_fractions((1+(1+1/a)/a)/a)
 ```
 """
 function flatten_fractions(x)
-    rules = [@acrule ~a::(x->x isa Div) + ~b => add_divs(~a,~b)
-             @rule *(~~x, ~a / ~b, ~~y) / ~c => *((~~x)..., ~a, (~~y)...) / (~b * ~c)
-             @rule ~c / *(~~x, ~a / ~b, ~~y)  => (~b * ~c) / *((~~x)..., ~a, (~~y)...)]
-    Fixpoint(Postwalk(Chain(rules)))(x)
+    Fixpoint(Postwalk(add_with_div))(x)
 end
 
 function fraction_iszero(x)
     !istree(x) && return _iszero(x)
+    ff = flatten_fractions(x)
     # fast path and then slow path
-    any(_iszero, numerators(flatten_fractions(x))) ||
-    any(_iszero∘expand, numerators(flatten_fractions(x)))
+    any(_iszero, numerators(ff)) ||
+    any(_iszero∘expand, numerators(ff))
 end
 
 function fraction_isone(x)

src/rewriters.jl

@@ -29,7 +29,7 @@ rewriters.
 
 """
 module Rewriters
-using SymbolicUtils: @timer
+using SymbolicUtils: @timer, unsorted_arguments
 using TermInterface: is_operation, istree, operation, similarterm, arguments, node_count
 
 export Empty, IfElse, If, Chain, RestartedChain, Fixpoint, Postwalk, Prewalk, PassThrough
@@ -159,7 +159,7 @@ function (p::Walk{ord, C, F, false})(x) where {ord, C, F}
             x = p.rw(x)
         end
         if istree(x)
-            x = p.similarterm(x, operation(x), map(PassThrough(p), arguments(x)))
+            x = p.similarterm(x, operation(x), map(PassThrough(p), unsorted_arguments(x)))
         end
         return ord === :post ? p.rw(x) : x
     else

src/rule.jl

@@ -356,7 +356,7 @@ function (acr::ACRule)(term)
         end
 
         T = symtype(term)
-        args = arguments(term)
+        args = unsorted_arguments(term)
 
         itr = acr.sets(eachindex(args), acr.arity)