mathai 0.4.0__py3-none-any.whl → 0.6.9__py3-none-any.whl

mathai/factor.py

@@ -1,10 +1,13 @@
 import itertools
+from .trig import trig0
 from .parser import parse
 from .structure import transform_formula
 from .base import *
-from .simplify import simplify,solve
+from .simplify import simplify
 from .expand import expand
 import math
+from .tool import poly
+from .fraction import fraction
 
 from collections import Counter
 def multiset_intersection(*lists):
@@ -30,8 +33,8 @@ def term_common2(eq):
     return product(s)*summation([product(subtract_sublist(factor_generation(child), s)) for child in eq.children])
 def term_common(eq):
     if eq.name == "f_add":
-        return solve(term_common2(eq))
-    return solve(product([term_common2(item) for item in factor_generation(eq)]))
+        return simplify(term_common2(eq))
+    return simplify(product([term_common2(item) for item in factor_generation(eq)]))
 def take_common(eq):
     if eq.name == "f_add":
         eq = term_common(eq)
@@ -41,7 +44,8 @@ def take_common(eq):
                     eq2 = summation([item2 for index, item2 in enumerate(eq.children) if index in item])
                     eq2 = term_common(eq2)
                     if eq2.name == "f_mul":
-                        return take_common(solve(summation([item2 for index, item2 in enumerate(eq.children) if index not in item]) + eq2))
+                        return take_common(simplify(summation([item2 for index, item2 in enumerate(eq.children) if index not in item]) + eq2))
+                break
         return eq
     return term_common(eq)
 def take_common2(eq):
@@ -52,10 +56,13 @@ def _factorconst(eq):
     def hcf_list(numbers):
         if not numbers:
             return None  # empty list
+        n = 1
+        if math.prod(numbers) < 0:
+            n = -1
         hcf = numbers[0]
         for num in numbers[1:]:
-            hcf = math.gcd(hcf, num)
-        return hcf
+            hcf = math.gcd(hcf, abs(num))
+        return hcf*n
     def extractnum(eq):
         lst = factor_generation(eq)
         for item in lst:
@@ -69,65 +76,230 @@ def _factorconst(eq):
     if n != 1:
         return tree_form("d_"+str(n))*eq
     return TreeNode(eq.name, [factorconst(child) for child in eq.children])
+
+def _merge_sqrt(eq):
+    lst= []
+    eq2 = []
+    for child in factor_generation(eq):
+        if frac(child) is not None and frac(child).denominator==1:
+            if frac(child)>0:
+                eq2.append(child**2)
+            elif frac(child)!=-1:
+                eq2.append((-child)**2)
+                lst.append(tree_form("d_-1"))
+            else:
+                lst.append(tree_form("d_-1"))
+        elif child.name == "f_pow" and frac(child.children[1]) == Fraction(1,2):
+            eq2.append(child.children[0])
+        else:
+            lst.append(child)
+            
+    if len(eq2)>1:
+        if lst == []:
+            lst= [tree_form("d_1")]
+        return simplify(product(eq2)**(tree_form("d_2")**-1)*product(lst))
+    return TreeNode(eq.name, [_merge_sqrt(child) for child in eq.children])
+def sqrt_to_a_sqrt_b(n):
+    if n == 0:
+        return 0, 0
+    sign = 1
+    if n < 0:
+        sign = -1
+        m = -n
+    else:
+        m = n
+
+    a = 1
+    b = 1
+    p = 2
+    while p * p <= m:
+        exp = 0
+        while m % p == 0:
+            m //= p
+            exp += 1
+        if exp:
+            a *= p ** (exp // 2)
+            if exp % 2 == 1:
+                b *= p
+        p += 1 if p == 2 else 2
+
+    if m > 1:
+        b *= m
+
+    return sign * a, b
+def merge_sqrt(eq):
+    def helper(eq):
+        if eq.name == "f_pow" and frac(eq.children[1]) == Fraction(1,2):
+            if eq.children[0].name[:2] == "d_":
+                n = int(eq.children[0].name[2:])
+                a, b =sqrt_to_a_sqrt_b(n)
+                return tree_form("d_"+str(b))**(tree_form("d_2")**-1)*tree_form("d_"+str(a))
+        return TreeNode(eq.name, [helper(child) for child in eq.children])
+    return helper(_merge_sqrt(eq))
+def rationalize_sqrt(eq):
+    if eq.name== "f_pow" and frac(eq.children[1]) == Fraction(-1,2):
+        eq = eq.children[0]**(tree_form("d_2")**-1)/eq.children[0]
+    def term(eq):
+        if eq.name == "f_add":
+            output = []
+            for child in eq.children:
+                if any(child2.name == "f_pow" and frac(child2.children[1]) == Fraction(1,2) for child2 in factor_generation(child)):
+                    output.append(simplify(-child))
+                else:
+                    output.append(child)
+            return summation(output)
+        return None
+    n, d=num_dem(eq)
+    n,d=simplify(n), simplify(d)
+   
+    if d != 1:
+        t = term(d)
+        if t is not None and t!=1:
+            
+            n,d=simplify(expand(simplify(n*t))),simplify(expand(simplify(d*t)))
+            tmp= simplify(n/d)
+            
+            tmp = _merge_sqrt(tmp)
+            
+            return tmp
+    return TreeNode(eq.name, [rationalize_sqrt(child) for child in eq.children])
 def factorconst(eq):
     return simplify(_factorconst(eq))
-def factor_quad_formula_init():
-    var = ""
-    formula_list = [(f"(A*D^2+B*D+C)", f"A*(D-(-B+(B^2-4*A*C)^(1/2))/(2*A))*(D-(-B-(B^2-4*A*C)^(1/2))/(2*A))")]
-    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
-    expr = [[parse("A"), parse("1")], [parse("B"), parse("0"), parse("1")], [parse("C"), parse("0")]]
-    return [formula_list, var, expr]
+
 def factor_quar_formula_init():
     var = ""
     formula_list = [(f"(A^4+B*A^2+C)", f"(A^2 + sqrt(2*sqrt(C) - B)*A + sqrt(C))*(A^2 - sqrt(2*sqrt(C) - B)*A + sqrt(C))")]
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A")], [parse("B"), parse("0"), parse("1")], [parse("C"), parse("0")]]
     return [formula_list, var, expr]
-def factor_cube_formula_init():
-    var = ""
-    formula_list = [(f"D^3+E", f"(D+E^(1/3))*(D^2-D*E^(1/3)+E^(2/3))"), (f"D^3-E", f"(D-E^(1/3))*(D^2+D*E^(1/3)+E^(2/3))"),\
-                    (f"-D^3+E", f"(-D+E^(1/3))*(D^2+D*E^(1/3)+E^(2/3))")]
-    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
-    expr = [[parse("A")], [parse("B")]]
-    return [formula_list, var, expr]
-formula_gen2 = factor_quad_formula_init()
-formula_gen3 = factor_cube_formula_init()
+
 formula_gen9 = factor_quar_formula_init()
+
 def factor_helper(equation, complexnum, power=2):
-    global formula_gen2, formula_gen3, formula_gen9
-    maxnum = 1
+    global formula_gen9
+    if equation.name in ["f_or", "f_and", "f_not", "f_eq", "f_gt", "f_lt", "f_ge", "f_le"]:
+        return TreeNode(equation.name, [factor_helper(child, complexnum, power) for child in equation.children])
+    maxnum=1
+    alloclst = []
+    for i in range(0,26):
+        if "v_"+str(i) not in vlist(equation):
+            alloclst.append("v_"+str(i))
+    r = alloclst.pop(0)
+    fx = None
+    curr = None
     def high(eq):
         nonlocal maxnum
         if eq.name == "f_pow" and eq.children[1].name[:2] == "d_":
             n = int(eq.children[1].name[2:])
-            if n>power and n % power == 0:
-                 maxnum = max(maxnum, n)
+            if abs(n)>power and abs(n) % power == 0:
+                if abs(n)>abs(maxnum):
+                    maxnum = n
         for child in eq.children:
             high(child)
     def helper(eq):
-        nonlocal maxnum
-        if eq.name == "f_pow" and eq.children[1].name[:2] == "d_":
+        nonlocal maxnum, fx, r
+        if eq.name == "f_pow" and eq.children[1].name[:2] == "d_" and eq.children[0] == curr:
             n = int(eq.children[1].name[2:])
-            sgn = round(abs(n)/n)
-            n = abs(n)
-            if n>power and n % power == 0 and maxnum==n:
-                out= (eq.children[0]**tree_form("d_"+str(sgn*int(n/power))))**power
+            if maxnum !=1 and n % maxnum == 0:
+                fx = lambda x: replace(x, tree_form(r), curr**tree_form("d_"+str(maxnum)))
+                out= tree_form(r)**tree_form("d_"+str(int(n/maxnum)))
                 return out
         return TreeNode(eq.name, [helper(child) for child in eq.children])
-    high(equation)
     out = None
-    if power == 2:
-        out = transform_formula(helper(equation), "v_0", formula_gen2[0], formula_gen2[1], formula_gen2[2])
-    elif power == 3:
-        out = transform_formula(helper(equation), "v_0", formula_gen3[0], formula_gen3[1], formula_gen3[2])
-    elif power == 4:
+    
+    for i in range(2,4):
+        if power == i:
+            for curr in vlist(equation):
+                curr = tree_form(curr)
+                fx = None
+                maxnum = 1
+                high(equation.copy_tree())
+                
+                if maxnum != 1:
+                    maxnum= maxnum/power
+                    maxnum = round(maxnum)
+                eq2 = helper(equation.copy_tree())
+                if not contain(eq2, tree_form(r)) or (contain(eq2, tree_form(r)) and not contain(eq2,curr)):
+                    if not contain(eq2, tree_form(r)):
+                        r = curr.name
+                        fx = lambda x: x
+                        
+                    lst = poly(eq2.copy_tree(), r)
+                    if lst is not None and len(lst)==i+1:
+                        
+                        success = True
+                        if i == 2:
+                            a, b, c = lst
+                            x1 = (-b+(b**2 - 4*a*c)**(tree_form("d_2")**-1))/(2*a)
+                            x2 = (-b-(b**2 - 4*a*c)**(tree_form("d_2")**-1))/(2*a)
+                            x1 = expand(simplify(x1))
+                            x2 = expand(simplify(x2))
+                            eq2 = a*(tree_form(r)-x1)*(tree_form(r)-x2)
+                            if not complexnum and (contain(x1, tree_form("s_i")) or contain(x2, tree_form("s_i"))):
+                                success = False
+                        else:
+                            a, b, c, d = lst
+                            B, C, D =  b/a, c/a, d/a
+                            p = C-(B**2)/3
+                            q = 2*B**3/27-B*C/3+D
+                            t = q**2/4+ p**3/27
+
+                            if compute(t) > 0:
+                                u = (-q/2+t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
+                                v = (-q/2-t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
+                                y1 = u+v
+                                three = 3**(tree_form("d_2")**-1)
+                                y2 = -(u+v)/2+tree_form("s_i")*three*(u-v)/2
+                                y3 = -(u+v)/2-tree_form("s_i")*three*(u-v)/2
+                                
+                            else:
+                                ar = 2*(-p/3)**(tree_form("d_2")**-1)
+                                phi = ((3*q/(2*p))*(-3/p)**(tree_form("d_2")**-1)).fx("arccos")
+                                y1 = ar*(phi/3).fx("cos")
+                                y2 = ar*((phi+2*tree_form("s_pi"))/3).fx("cos")
+                                y3 = ar*((phi+4*tree_form("s_pi"))/3).fx("cos")
+                                
+                            x1,x2,x3 = y1-B/3 , y2-B/3, y3-B/3
+                            x1 = simplify(trig0(simplify(x1)))
+                            x2 = simplify(trig0(simplify(x2)))
+                            x3 = simplify(trig0(simplify(x3)))
+                            
+                            out2 = None
+                            if not complexnum:
+                                for item in itertools.combinations([x1,x2,x3],2):
+                                    if all(contain(item2,tree_form("s_i")) for item2 in list(item)):
+                                        out2 = (tree_form(r)-item[0])*(tree_form(r)-item[1])
+                                        break
+                            if out2 is not None:
+                                out2 = simplify(fraction(expand(simplify(out2))))
+                                out3 = None
+                                for item in [x1, x2, x3]:
+                                    if not contain(item,tree_form("s_i")):
+                                        out3 = item
+                                        break
+                                eq2 = a*(tree_form(r)-out3)*out2
+                                
+                            else:
+                                eq2 = a*(tree_form(r)-x1)*(tree_form(r)-x2)*(tree_form(r)-x3)
+                        if success:
+                            equation = fx(eq2)
+                            break
+    
+    if False and power == 4:
+        
         out = transform_formula(helper(equation), "v_0", formula_gen9[0], formula_gen9[1], formula_gen9[2])
+    
     if out is not None:
-        out = simplify(solve(out))
+        out = simplify(out)
     if out is not None and (complexnum or (not complexnum and not contain(out, tree_form("s_i")))):
         return out
+    
     return TreeNode(equation.name, [factor_helper(child, complexnum, power) for child in equation.children])
-def factor(equation, complexnum=False):
-    return solve(take_common2(simplify(factor_helper(simplify(equation), complexnum, 2))))
+def factor(equation):
+    return simplify(take_common2(simplify(equation)))
+
 def factor2(equation, complexnum=False):
-    return solve(factor_helper(solve(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3)), complexnum, 4))
+    return simplify(factor_helper(simplify(equation), complexnum, 2))
+
+def factor3(equation, complexnum=False):
+    return simplify(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3))

mathai/fraction.py

@@ -1,5 +1,5 @@
 from .base import *
-from .simplify import solve, simplify
+from .simplify import simplify
 from .expand import expand
 
 def fraction(eq):
@@ -100,4 +100,4 @@ def fraction(eq):
         result_map[node] = TreeNode(node.name, children_processed)
 
     # Final return
-    return solve(result_map[eq])
+    return simplify(result_map[eq])

mathai/integrate.py

@@ -3,7 +3,7 @@ from .parser import parse
 import itertools
 from .diff import diff
 from .fraction import fraction
-from .simplify import solve, simplify
+from .simplify import simplify
 from .expand import expand
 from .base import *
 from .printeq import printeq_str
@@ -31,8 +31,13 @@ def integrate_summation(equation):
 def subs_heuristic(eq, var):
     output = []
     def collect2(eq):
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) == Fraction(1,2):
+            
+            if eq.children[0] == var:
+                output.append(str_form(eq))
         if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]).denominator == 1 and abs(frac(eq.children[1]).numerator) % 2 == 0:
-            output.append(str_form(eq.children[0]**2))
+            if len(eq.children[0].children) == 0 or eq.children[0].children[0] == var:
+                output.append(str_form(eq.children[0]**2))
         if eq.name in ["f_pow", "f_sin", "f_cos", "f_arcsin"] and var.name in str_form(eq.children[0]):
             if eq.children[0].name[:2] != "v_":
                 output.append(str_form(eq.children[0]))
@@ -57,12 +62,27 @@ def subs_heuristic(eq, var):
     
     tmp = list(set([simplify(tree_form(x)) for x in output]))
     tmp = sorted(tmp, key=lambda x: len(str(x)))
-    return tmp
+    poly_term = None
+    term_degree = 100
+    output = []
+    for item in tmp:
+        n = poly(simplify(item), var.name)
+        if n is None:
+            output.append(item)
+        else:
+            if term_degree > len(n):
+                poly_term = item
+                term_degree = len(n)
+    if poly_term is None:
+        return tmp
+    return [poly_term]+output
 try_index = []
 try_lst = []
 def ref(eq):
+    '''
     if eq.name in ["f_try", "f_ref"]:
         return eq
+    '''
     if eq.name  == "f_integrate":
         return TreeNode("f_try", [eq.fx("ref"), eq])
     return TreeNode(eq.name, [ref(child) for child in eq.children])
@@ -80,12 +100,12 @@ def _solve_integrate(eq):
     if eq.name == "f_ref":
         return eq
     if eq.name == "f_subs":
-        if "f_integrate" not in str_form(eq.children[0]):
+        if all(item not in str_form(eq.children[0]) for item in ["f_integrate", "f_subs", "f_try"]):
             return replace(eq.children[0], eq.children[1], eq.children[2])
     
     if eq.name == "f_try":
         for child in eq.children:
-            if "f_integrate" not in str_form(child):
+            if all(item not in str_form(child) for item in ["f_integrate", "f_subs", "f_try"]):
                 return child
     return TreeNode(eq.name, [_solve_integrate(child) for child in eq.children])
 def handle_try(eq):
@@ -104,8 +124,6 @@ def handle_try(eq):
     else:
         return TreeNode(eq.name, [handle_try(child) for child in eq.children])
 def inteq(eq):
-    if "f_ref" not in str_form(eq):
-        return eq
     if eq.name == "f_try":
         eq2 = None
         output = []
@@ -113,35 +131,45 @@ def inteq(eq):
             if child.name == "f_ref":
                 eq2 = child.children[0]
                 break
+        if eq2 is None:
+            return eq
+        printeq(eq)
         for child in eq.children:
             if child.name == "f_ref":
                 output.append(child)
             else:
                 eq3 = simplify(expand(simplify(eq2 - child)))
                 if contain(eq3, eq2):
-                    output.append(inverse(eq3, str_form(eq2)))
+                    out = inverse(eq3, str_form(eq2))
+                    if out is None:
+                        output.append(child)
+                    else:
+                        output.append(out)
                 else:
                     output.append(child)
+        printeq(TreeNode("f_try", output))
+        print()
         return TreeNode("f_try", output)
     else:
         return TreeNode(eq.name, [inteq(child) for child in eq.children])
 def rm(eq):
     if eq.name == "f_try":
         eq = TreeNode(eq.name, list(set(eq.children)))
-    return TreeNode(eq.name, [rm(child) for child in eq.children])
+    return TreeNode(eq.name, [rm(child) for child in eq.children if child is not None])
 def solve_integrate(eq):
     
     eq2 = dowhile(eq, _solve_integrate)
     eq2 = dowhile(eq2, handle_try)
     eq2 = rm(eq2)
-    eq2.children = list(set(eq2.children))
+    if eq2.name == "f_try":
+        eq2.children = list(set(eq2.children))
     return eq2
 def integrate_subs(equation, term, v1, v2):
     output = []
     orig = equation.copy_tree()
     none = TreeNode("f_integrate",[orig, tree_form(v1)])
     origv2 = copy.deepcopy(v2)
-    equation = solve(equation)
+    equation = simplify(equation)
     eq = equation
     termeq = term
     t = inverse(copy.deepcopy(termeq), v1)
@@ -159,13 +187,13 @@ def integrate_subs(equation, term, v1, v2):
                
         eq2 = replace(diff(g, v1), tree_form(v1), t)
         equation = eq/eq2
-        equation = solve(equation)
+        equation = simplify(equation)
         
     if v1 in str_form(equation):
         
         return none
 
-    return TreeNode("f_subs", [TreeNode("f_integrate", [simplify(expand(simplify(equation))), tree_form(origv2)]),tree_form(origv2) ,g])
+    return dowhile(TreeNode("f_subs", [TreeNode("f_integrate", [simplify(equation), tree_form(origv2)]),tree_form(origv2) ,g]), trig0)
 
 def integrate_subs_main(equation):
     if equation.name == "f_ref":
@@ -291,7 +319,7 @@ def _sqint(equation):
     return coll
 
 def sqint(eq):
-    out = _sqint(eq)
+    out = simplify(_sqint(eq))
     if out is None:
         return eq
     return out
@@ -307,13 +335,20 @@ def byparts(eq):
         lst = factor_generation(eq)
         if len(lst) == 3 and len(list(set(lst))) == 1:
             lst = [(lst[0]**2).copy_tree(), lst[0].copy_tree()]
+        if len(lst) == 3 and len(list(set(lst))) == 2:
+            lst2 = list(set(lst))
+            a, b = lst2
+            a = a**lst.count(a)
+            b = b**lst.count(b)
+            lst = [a.copy_tree(), b.copy_tree()]
         if len(lst) == 1:
             lst += [tree_form("d_1")]
         if len(lst) == 2:
             for i in range(2):
                 
                 f, g = [lst[i], lst[1-i]]
-                
+                if contain(f, tree_form("s_e")):
+                    continue
                 out1 = TreeNode("f_integrate", [g.copy_tree(), wrt])
 
                 
@@ -331,18 +366,20 @@ def byparts(eq):
 
 def integration_formula_init():
     var = "x"
-    formula_list = [(f"(A*{var}+B)^C", f"(A*{var}+B)^(C+1)/(A*(C+1))"),\
-                    (f"sin(A*{var}+B)", f"-cos(A*{var}+B)/A"),\
-                    (f"cos(A*{var}+B)", f"sin(A*{var}+B)/A"),\
-                    (f"1/(A*{var}+B)", f"log(abs(A*{var}+B))/A"),\
-                    (f"e^(A*{var}+B)", f"e^(A*{var}+B)/A"),\
-                    (f"1/cos({var})", f"log(abs((1+sin({var}))/cos({var})))"),\
-                    (f"1/cos({var})^2", f"sin({var})/cos({var})"),\
-                    (f"abs(A*{var}+B)", f"(A*{var}+B)*abs(A*{var}+B)/(2*A)")]
+    formula_list = [
+        (f"(A*{var}+B)^C", f"(A*{var}+B)^(C+1)/(A*(C+1))"),
+        (f"sin(A*{var}+B)", f"-cos(A*{var}+B)/A"),
+        (f"cos(A*{var}+B)", f"sin(A*{var}+B)/A"),
+        (f"1/(A*{var}+B)", f"log(abs(A*{var}+B))/A"),
+        (f"e^(A*{var}+B)", f"e^(A*{var}+B)/A"),
+        (f"1/cos(A*{var}+B)", f"log(abs((1+sin(A*{var}+B))/cos(A*{var}+B)))"),
+        (f"1/cos(A*{var}+B)^2", f"tan(A*{var}+B)/A"),
+        (f"1/sin(A*{var}+B)", f"log(abs(tan((A*{var}+B)/2)))/A"),
+        (f"1/cos(A*{var}+B)^3", f"(sec(A*{var}+B)*tan(A*{var}+B)+log(abs(sec(A*{var}+B)+tan(A*{var}+B))))/(2*A)")
+    ]
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A"), parse("1")], [parse("B"), parse("0")]]
     return [formula_list, var, expr]
-formula_gen = integration_formula_init()
 def integration_formula_trig():
     var = "x"
     formula_list = [(f"(A+B*sin({var})+C*cos({var}))/(D+E*sin({var})+F*cos({var}))", f"((B*E+C*F)/(E^2+F^2))*{var}+((C*E-B*F)/(E^2+F^2))*log(D+E*sin({var})+F*cos({var}))")]
@@ -353,15 +390,31 @@ def integration_formula_trig():
     return [formula_list, var, expr]
 
 
+formula_gen = integration_formula_init()
 formula_gen4 = integration_formula_trig()
 
+
+def integration_formula_ex():
+    var = "x"
+    formula_list = [
+        (
+            f"e^(A*{var})*cos(B*{var})",
+            f"e^(A*{var})*(A*cos(B*{var}) + B*sin(B*{var}))/(A^2 + B^2)"
+        )
+    ]
+    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
+    expr = [[parse("A"), parse("1")], [parse("B"), parse("1")]]
+    return [formula_list, var, expr]
+
+formula_gen11 = integration_formula_ex()
 def rm_const(equation):
     if equation.name == "f_ref":
         return equation
     eq2 = equation
-    if eq2.name == "f_integrate":
+    if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
         wrt = eq2.children[1]
+        
         lst = factor_generation(equation)
         
         lst_const = [item for item in lst if not contain(item, wrt)]
@@ -376,6 +429,11 @@ def rm_const(equation):
                 return rm_const(TreeNode("f_integrate",[equation, wrt])) *const
         equation = eq2
     return TreeNode(equation.name, [rm_const(child)  for child in equation.children])
+
+def shorten(eq):
+    if eq.name.startswith("d_"):
+        return tree_form("d_0")
+    return TreeNode(eq.name, [shorten(child) for child in eq.children])
 def integrate_formula(equation):
     if equation.name == "f_ref":
         return equation.copy_tree()
@@ -384,17 +442,21 @@ def integrate_formula(equation):
         integrand = eq2.children[0]
         wrt = eq2.children[1]
         if integrand == wrt:
-            return TreeNode("f_add", [TreeNode("f_power", [wrt.copy_tree(), TreeNode("2")]), TreeNode("f_div", [TreeNode("1"), TreeNode("2")])])  # x^2/2
+            return wrt**2/2  # x^2/2
         if not contain(integrand, wrt):
-            return TreeNode("f_mul", [wrt.copy_tree(), integrand.copy_tree()])  # constant * dx
+            return integrand*wrt
         out = transform_formula(simplify(trig0(integrand)), wrt.name, formula_gen[0], formula_gen[1], formula_gen[2])
         if out is not None:
+            
             return out
-        expr_str = str_form(integrand)
-        if expr_str.count("f_sin") + expr_str.count("f_cos") > 2:
-            out = transform_formula(integrand, wrt.name, formula_gen4[0], formula_gen4[1], formula_gen4[2])
-            if out is not None:
-                print(out, 111)
-                return out
+        expr_str = str_form(shorten(integrand))
+        if len(expr_str) < 30:
+            if expr_str.count("f_sin") + expr_str.count("f_cos") > 2:
+                out = transform_formula(integrand, wrt.name, formula_gen4[0], formula_gen4[1], formula_gen4[2])
+                if out is not None:
+                    return out
+            if "f_cos" in expr_str and contain(integrand, tree_form("s_e")):
+                out = transform_formula(integrand, wrt.name, formula_gen11[0], formula_gen11[1], formula_gen11[2])
+                if out is not None:
+                    return out
     return TreeNode(eq2.name, [integrate_formula(child) for child in eq2.children])
-

mathai/inverse.py

@@ -1,5 +1,5 @@
 from .base import *
-from .simplify import solve
+from .simplify import simplify
 from .expand import expand
 def inverse(rhs,term, sign=None):
     term = tree_form(term)
@@ -9,7 +9,7 @@ def inverse(rhs,term, sign=None):
     while not rhs==term:
         if rhs.name == "f_add":
             if all(term in factor_generation(child) for child in rhs.children):
-                newrhs = solve(expand(rhs*term**-1))
+                newrhs = simplify(expand(rhs*term**-1))
                 if not contain(newrhs, term):
                     rhs = term * newrhs
             else:
@@ -61,5 +61,5 @@ def inverse(rhs,term, sign=None):
         if count == 0:
             return None
     if sign is None:
-        return solve(lhs)
-    return solve(lhs), sign
+        return simplify(lhs)
+    return simplify(lhs), sign