symbolic tests added

Author: shahriariravanian

src/integral.jl

@@ -109,7 +109,7 @@ function integrate_sum(eq, x; bypass = false, kwargs...)
         ε₀ = max(ε₀, ε)
     end
 
-    if !isequal(unsolved, 0) && isempty(const_params(unsolved, x))
+    if !isequal(unsolved, 0) && isempty(sym_consts(unsolved, x))
         eq = factor_rational(simplify_trigs(unsolved))
 
         if !isequal(eq, unsolved)

src/symbolic.jl

@@ -1,42 +1,26 @@
-function extract_real(y)
-    if istree(y)
-        if is_add(y)
-            return sum(extract_real(t) for t in args(y))
-        elseif is_mul(y)
-            return prod(extract_real(t) for t in args(y))
-        elseif is_div(y)
-            return extract_real(numer(y)) / extract_real(denom(y))
-        elseif is_pow(y)
-            q = args(p)[1]
-            k = args(p)[2]
-            return extract_real(q) ^ k
-        else
-            return y
-        end
-    else
-        return real(y)
-    end
-end
-
-
-function beautify(coef)
-    if is_add(coef)
-        return sum(beautify(t) for t in args(coef))
-    elseif is_mul(coef)
-        return prod(beautify(t) for t in args(coef))
-    elseif is_pow(coef)
-        p = args(coef)[1]
-        k = args(coef)[2]
+"""
+    Convers floats to integers/rational numbers with small denominators 
+    if possible
+"""
+function beautify(eq)
+    if is_add(eq)
+        return sum(beautify(t) for t in args(eq))
+    elseif is_mul(eq)
+        return prod(beautify(t) for t in args(eq))
+    elseif is_pow(eq)
+        p = args(eq)[1]
+        k = args(eq)[2]
         return beautify(p) ^ k
-    elseif is_div(coef)
-        return beautify(numer(coef)) / beautify(denom(coef))
-    elseif is_number(coef)
-        return nice_parameter(coef)
+    elseif is_div(eq)
+        return beautify(numer(eq)) / beautify(denom(eq))
+    elseif is_number(eq)
+        return nice_parameter(eq)
     else
-        return coef
+        return eq
     end
 end
 
+
 ###################################################################
 
 """

test/runtests.jl

@@ -11,7 +11,7 @@ include("axiom.jl")
 
 ##############################################################################
 
-@variables x β
+@variables x a b β
 
 """
     a list of basic standard integral tests
@@ -205,17 +205,77 @@ basic_integrals = [
     1 / log(x) - 1 / log(x)^2,
 ]
 
-function test_integrals(subs=nothing, rng=nothing;  kw...)
+
+sym_integrals = [
+    # Basic Forms
+    a*x^2,
+    a / x,
+    1 / (a*x + 5),
+    1 / (x + a)^2,
+    (x + a)^3,
+    x * (x - a)^4,
+    1 / (a + x^2),
+    sqrt(x - a),
+    1 / sqrt(a*x - 1),
+    x * sqrt(a*x + b),
+    log(a*x),
+    x * log(a*x),
+    x^2 * log(a*x),
+    log(a*x) / x,
+    log(x^2 - a*x + b),
+    log(a*x)^2,
+    x^2 * log(a*x+b)^2,
+    exp(a*x),
+    x * exp(a*x),
+    x^2 * exp(a*x),
+    x * exp(a*x^2),
+    sin(a*x),
+    sin(a*x)^2,
+    cos(a*x + b)^2,
+    sin(a*x) * cos(a*x),
+    sin(a*x) * cos(b*x),
+    tan(a*x),
+    sec(a*x),
+    x * cos(a*x),
+    x^2 * cos(a*x),
+    sin(a*x)^2 * cos(b*x)^3,
+    exp(a*x) * sin(b*x),
+    x * exp(a*x) * sin(a*x),
+    x * exp(a*x) * cos(b*x),
+    cosh(a*x),
+    exp(a*x) * cosh(b*x),
+    cos(a*x) * cosh(b*x),
+    sec(a*x)^2 * tan(a*x),
+    exp(a*x) / (1 + exp(a*x)),
+    cos(exp(a*x)) * sin(exp(a*x)) * exp(a*x),
+    1 / (x * log(a*x)),
+    log(log(a*x)) / x,
+    sin(log(a*x)),
+    x / (exp(a*x) - b),
+    exp(a*x) * exp(exp(a*x)),
+    log(cos(a*x)) * tan(a*x),
+    1 / (x^3 + a),
+    exp(a*x+b) / x,
+    sin(x + a) / (x + a),
+    cos(a*x) / x,
+    x / log(a*x^2),
+    # bypass = true
+    β,      # turn of bypass = true
+    exp(a*x) / x - exp(a*x) / x^2,
+    cos(a*x) / x - sin(a*x) / x^2,
+]
+
+
+function test_integrals(basis=true, subs=nothing;  kw...)
     args = isempty(kw) ? Dict() : Dict(kw)
     args[:detailed] = false
     misses = []
     k = 1        
+    
+    integrals = basis ? basic_integrals : sym_integrals    
+    args[:symbolic] = !basis
 
-    for (i, eq) in enumerate(basic_integrals)
-        if rng != nothing && !(i in rng)
-            continue
-        end
-        
+    for (i, eq) in enumerate(integrals)
         if isequal(eq, β)
             printstyled("**** bypass on ****\n"; color = :red)
             bypass = true