upgraded to version 0.7.0; homotopy is true by default

Author: shahriariravanian

Project.toml

@@ -1,7 +1,7 @@
 name = "SymbolicNumericIntegration"
 uuid = "78aadeae-fbc0-11eb-17b6-c7ec0477ba9e"
 authors = ["Shahriar Iravanian <[email protected]>"]
-version = "0.6.3"
+version = "0.7.0"
 
 [deps]
 DataDrivenDiffEq = "2445eb08-9709-466a-b3fc-47e12bd697a2"

README.md

@@ -63,10 +63,11 @@ julia> integrate(exp(x^2))
 * `abstol` (default `1e-6`): the error tolerance to accept a solution.
 * `symbolic` (default `true`): if true, pure symbolic integration is attempted first.
 * `bypass` (default `false`): if true, the whole expression is considered at once and not per term.
-* `bypart` (default `true`): if true, integration by parts is tried.
+* `bypart` (default `false`, turned off in version 0.7.0): if true, integration by parts is tried.
 * `num_steps` (default `2`): one plus the number of expanded basis to check (if `num_steps` is 1, only the main basis is checked).
 * `num_trials` (default `5`): the number of attempts to solve the integration numerically for each basis set.
 * `show_basis` (default `false`): print the basis set, useful for debugging. Only works if `verbose` is also set.
+* `homotopy` (default: `true` as of version 0.7.0): uses the continuous Homotopy operators to generate the integration candidates.
 * `verbose` (default `false`): if true, prints extra (and voluminous!) debugging information.
 * `radius` (default `1.0`): the starting radius to generate random test points.
 * `opt` (default `STLSQ(exp.(-10:1:0))`): the optimizer passed to `sparse_regression!`.
@@ -84,8 +85,8 @@ Additionally, 12 test suites from the *Rule-based Integrator* ([Rubi](https://ru
   using SymbolicNumericIntegration
   include("test/axiom.jl")  # note, you may need to use the correct path
 
-  L = convert_axiom(:Apostle)   # can also use L = convert_axiom(1)
-  test_axiom(L, false; bypart=true, bypass=false, verbose=true)
+  L = convert_axiom(:Apostle)   # can also use L = convert_axiom(1)  
+  test_axiom(L, false; bypart=false, bypass=false, verbose=false, homotopy=true)
 ```
 
 The test suites description based on the header of the files in the Rubi directory are

src/SymbolicNumericIntegration.jl

@@ -1,4 +1,4 @@
-# module SymbolicNumericIntegration
+module SymbolicNumericIntegration
 
 using SymbolicUtils
 using SymbolicUtils: istree, operation, arguments
@@ -27,4 +27,4 @@ include("integration_by_parts.jl")
 include("logger.jl")
 include("prune.jl")
 
-# end # module
+end # module

src/candidates.jl

@@ -14,25 +14,25 @@ function generate_basis(eq, x; homotopy=false)
 
         if homotopy
             if isdependent(p, x)
-                C₂ = generate_homotopy2(p, x)
+                C₂ = generate_homotopy(p, x)
             else
                 C₂ = 1
             end
         else
-            C₂ = find_candidates_nonsolvable(p, x)
+            C₂ = find_candidates(p, x)
         end
 
         for c₁ in C₁
-            enqueue_expr_ex!(S, c₁, x)
+            enqueue_expr!(S, c₁, x)
         end
 
         for c₂ in C₂
-            enqueue_expr_ex!(S, c₂, x)
+            enqueue_expr!(S, c₂, x)
         end
 
         for c₁ in C₁
             for c₂ in C₂
-                enqueue_expr_ex!(S, expand(c₁*c₂), x)
+                enqueue_expr!(S, expand(c₁*c₂), x)
             end
         end
     end
@@ -53,26 +53,26 @@ function closure(eq, x; max_terms=50)
     D = Differential(x)
     S = Set{Any}()
     q = Queue{Any}()
-    enqueue_expr_ex!(S, q, eq, x)
+    enqueue_expr!(S, q, eq, x)
 
     while !isempty(q) && length(S) < max_terms
         y = dequeue!(q)
-        enqueue_expr_ex!(S, q, expand_derivatives(D(y)), x)
+        enqueue_expr!(S, q, expand_derivatives(D(y)), x)
     end
     unique([one(x); [s for s in S]; [s*x for s in S]])
 end
 
-function find_candidates_nonsolvable(eq, x)
+function find_candidates(eq, x)
     eq = apply_d_rules(eq)
     D = Differential(x)
 
     S = Set{Any}()
     q = Queue{Any}()
-    enqueue_expr_ex!(S, q, eq, x)
+    enqueue_expr!(S, q, eq, x)
 
     for y in q
         ∂y = expand_derivatives(D(y))
-        enqueue_expr_ex!(S, ∂y, x)
+        enqueue_expr!(S, ∂y, x)
     end
 
     return unique([one(x); [s for s in S]])
@@ -146,43 +146,22 @@ function enqueue_expr!(S, q, eq::SymbolicUtils.Add, x)
 end
 
 function enqueue_expr!(S, q, eq, x)
-    y = eq / coef(eq, x)
-    if y ∉ S && isdependent(y, x) # && all(u->u>=0, extract_power(y))
-        enqueue!(q, y)
-        push!(S, y)
-    end
-end
-
-function enqueue_expr_ex!(S, q, eq::SymbolicUtils.Add, x)
-    for t in arguments(eq)
-        enqueue_expr_ex!(S, q, t, x)
-    end
-end
-
-function enqueue_expr_ex!(S, q, eq, x)
     y = eq / coef(eq, x)
     if y ∉ S && isdependent(y, x)
         enqueue!(q, y)
         push!(S, y)
     end
 end
 
-function enqueue_expr_ex!(S, eq::SymbolicUtils.Add, x)
+function enqueue_expr!(S, eq::SymbolicUtils.Add, x)
     for t in arguments(eq)
-        enqueue_expr_ex!(S, t, x)
+        enqueue_expr!(S, t, x)
     end
 end
 
-function enqueue_expr_ex!(S, eq, x)
+function enqueue_expr!(S, eq, x)
     y = eq / coef(eq, x)
     if y ∉ S && isdependent(y, x)
         push!(S, y)
     end
 end
-
-###############################################################################
-
-extract_power(eq::SymbolicUtils.Pow) = [arguments(eq)[2]]
-extract_power(eq::SymbolicUtils.Term) = [1]
-extract_power(eq::SymbolicUtils.Mul) = union([extract_power(t) for t in arguments(eq)]...)
-extract_power(eq) = []