mathai 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

mathai/__init__.py

@@ -1,16 +1,46 @@
 from .expand import expand
+
 from .parser import parse
+
 from .printeq import printeq, printeq_log, printeq_str
+
 from .simplify import solve, simplify, solve2
-from .integrate import integrate, sqint, byparts
+
+from .integrate import ref as integrate_save
+from .integrate import integrate_subs_main as integrate_subs
+from .integrate import byparts as integrate_byparts
+from .integrate import sqint as integrate_fraction
+from .integrate import integrate_summation
+from .integrate import rm_const as integrate_const
+from .integrate import solve_integrate as integrate_clean
+from .integrate import inteq as integrate_recursive
+from .integrate import integrate_formula
+
 from .diff import diff
-from .factor import factor, factor2
+
+from .factor import factor as factor1
+from .factor import factor2
+from .factor import factorconst as factor0
+
 from .fraction import fraction
+
 from .inverse import inverse
+
 from .trig import trig0, trig1, trig2, trig3, trig4
+
 from .logic import logic0, logic1, logic2, logic3
+
 from .apart import apart
+
 from .console import console
+
 from .limit import limit
+
+from .search import dfs_simplify as search0
+
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
+
 from .base import *
+
+from .tool import enclose_const
+

mathai/apart.py

@@ -5,16 +5,18 @@ from .diff import diff
 from .inverse import inverse
 from .base import *
 import math
-from .tool import poly
+from .tool import poly, enclose_const
 
-def apart(eq, v="v_0"):
+def _apart(eq, v="v_0"):
+    
+    origv = vlist(eq)
     eq = simplify(eq)
     if eq.name != "f_mul":
         return eq
     if any("f_"+item in str_form(eq) for item in "sin cos tan log".split(" ")):
         return eq
     def exclude(eq):
-        if eq.name == "f_pow" and eq.children[1].name[:2] != "d_":
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]).denominator != 1:
             return False
         if any(not exclude(child) for child in eq.children):
             return False
@@ -47,6 +49,7 @@ def apart(eq, v="v_0"):
     x = tree_form(v)
     num = []
     dem = []
+    
     for item in facd2:
         
         g = countfac(facd, item)
@@ -94,10 +97,17 @@ def apart(eq, v="v_0"):
     lst = poly(s.children[0], v)
     
     lst = [TreeNode("f_eq", [item, tree_form("d_0")]) for item in lst if "v_" in str_form(item)]
-   
-    out = linear_solve(TreeNode("f_and", lst))
-    
+    lst2 = []
+    for item in lst:
+        lst2+=vlist(item)
+    origv = list(set(lst2)-set(origv))
+    out = linear_solve(TreeNode("f_and", lst), [tree_form(item) for item in origv])
     for item in out.children:
         
-        final3 = replace(final3, tree_form(vlist(item)[0]), inverse(item.children[0], vlist(item)[0]))
+        final3 = replace(final3, tree_form(list(set(vlist(item))&set(origv))[0]), inverse(item.children[0], list(set(vlist(item))&set(origv))[0]))
     return simplify(final3)
+def apart(eq):
+    eq, fx = enclose_const(eq)
+    
+    eq = _apart(eq)
+    return fx(eq)

mathai/base.py

@@ -3,7 +3,8 @@ from fractions import Fraction
 
 class TreeNode:
     def __init__(self, name, children=[]):
-        children = copy.deepcopy(children)
+        
+        children = [child.copy_tree() for child in children]
         self.name = name
         if name in ["f_add", "f_mul"]:
             self.children = sorted(children, key=lambda x: str_form(x))
@@ -12,6 +13,11 @@ class TreeNode:
 
     def fx(self, fxname):
         return TreeNode("f_" + fxname, [self])
+    def copy_tree(node):
+        if node is None:
+            return None
+
+        return tree_form(str_form(node))
 
     def __repr__(self):
         return string_equation(str_form(self))
@@ -281,10 +287,11 @@ def flatten_tree(node):
         return node
 def dowhile(eq, fx):
     while True:
-        orig = copy.deepcopy(eq)
-        eq = copy.deepcopy(fx(eq))
-        if eq is None:
+        orig = eq.copy_tree()
+        eq2 = fx(eq)
+        if eq2 is None:
             return None
+        eq = eq2.copy_tree()
         if eq == orig:
             return orig
 def tree_form(tabbed_strings):
@@ -318,7 +325,7 @@ def string_equation_helper(equation_tree):
     if equation_tree.name == "f_index":
         return string_equation_helper(equation_tree.children[0])+"["+",".join([string_equation_helper(child) for child in equation_tree.children[1:]])+"]"
     s = "(" 
-    if len(equation_tree.children) == 1 or equation_tree.name[2:] in [chr(ord("A")+i) for i in range(26)]+["exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
+    if len(equation_tree.children) == 1 or equation_tree.name[2:] in [chr(ord("A")+i) for i in range(26)]+["subs", "try", "ref", "integrate", "exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
         s = equation_tree.name[2:] + s
     sign = {"f_not":"~", "f_addw":"+", "f_mulw":"*", "f_intersection":"&", "f_union":"|", "f_sum2":",", "f_exist":",", "f_forall":",", "f_sum":",","f_covariance": ",", "f_B":",", "f_imply":"->", "f_ge":">=", "f_le":"<=", "f_gt":">", "f_lt":"<", "f_cosec":"?" , "f_equiv": "<->", "f_sec":"?", "f_cot": "?", "f_dot": ".", "f_circumcenter":"?", "f_transpose":"?", "f_exp":"?", "f_abs":"?", "f_log":"?", "f_and":"&", "f_or":"|", "f_sub":"-", "f_neg":"?", "f_inv":"?", "f_add": "+", "f_mul": "*", "f_pow": "^", "f_poly": ",", "f_div": "/", "f_sub": "-", "f_dif": ",", "f_sin": "?", "f_cos": "?", "f_tan": "?", "f_eq": "=", "f_sqrt": "?"}
     arr = []
@@ -328,7 +335,7 @@ def string_equation_helper(equation_tree):
     else:
         k = sign[equation_tree.name]
     for child in equation_tree.children:
-        arr.append(string_equation_helper(copy.deepcopy(child)))
+        arr.append(string_equation_helper(child.copy_tree()))
     outfinal = s + k.join(arr) + ")"+extra
     
     return outfinal.replace("+-", "-")

mathai/console.py

@@ -3,7 +3,7 @@ from .expand import expand
 from .parser import parse
 from .printeq import printeq, printeq_log
 from .simplify import solve, simplify
-from .integrate import integrate, typesqint, typebyparts, typeintegrate
+
 from .diff import diff
 from .base import *
 from .factor import _factorconst, factor

mathai/diff.py

@@ -1,6 +1,6 @@
 from .simplify import solve
 from .base import *
-
+from .trig import trig0
 def diff(equation, var="v_0"):
     def diffeq(eq):
         eq = solve(eq)
@@ -53,13 +53,16 @@ def diff(equation, var="v_0"):
             b1 = power - tree_form("d_1")
             bab1 = TreeNode("f_pow", [base, b1])
             return power * bab1 * dbase
-        return eq.fx("dif")
+        return TreeNode("f_dif", [eq, tree_form(var)])
     def helper(equation, var="v_0"):
         if equation.name == "f_dif":
             if equation.children[0].name == var:
                 return tree_form("d_1")
-            return tree_form("d_0")
+            if var not in str_form(equation.children[0]):
+                return tree_form("d_0")
+            else:
+                return equation
         return TreeNode(equation.name, [helper(child, var) for child in equation.children])
-    equation = diffeq(equation)
+    equation = diffeq(trig0(equation))
     equation = helper(equation, var)
     return solve(equation)

mathai/expand.py

@@ -1,4 +1,3 @@
-
 import itertools
 from .base import *
 from .simplify import solve, simplify
@@ -6,53 +5,92 @@ from .simplify import solve, simplify
 def expand(eq):
     if eq is None:
         return None
-    if eq.name == "f_mul" or eq.name == "f_pow":
-        if eq.name == "f_pow":
-            eq = TreeNode("f_pow", [eq]) 
-        ac = []
-        addchild = []
-        for child in eq.children:
-            tmp5 = [solve(x) for x in factor_generation(child)]
-            ac += tmp5
-        tmp3 = []
-        for child in ac:
-            tmp2 = []
-            if child.name == "f_add":
-                if child.children != []:
-                    for child2 in child.children:
-                        tmp2.append(child2)
+
+    stack = [(eq, 0)]  # (node, stage)
+    result_map = {}     # id(node) -> expanded TreeNode
+
+    while stack:
+        node, stage = stack.pop()
+        node_id = id(node)
+
+        # Leaf node
+        if not node.children and stage == 0:
+            result_map[node_id] = TreeNode(node.name, [])
+            continue
+
+        if stage == 0:
+            # Stage 0: push node back for stage 1 after children
+            stack.append((node, 1))
+            # Push children to stack
+            for child in reversed(node.children):
+                if id(child) not in result_map:
+                    stack.append((child, 0))
+        else:
+            # Stage 1: all children processed
+            children_expanded = [result_map[id(child)] for child in node.children]
+
+            # Only f_mul or f_pow need special expansion
+            if node.name in ["f_mul", "f_pow"]:
+                current_eq = TreeNode(node.name, children_expanded)
+
+                if node.name == "f_pow":
+                    current_eq = TreeNode("f_pow", [current_eq])
+
+                ac = []
+                addchild = []
+
+                for child in current_eq.children:
+                    tmp5 = [solve(x) for x in factor_generation(child)]
+                    ac += tmp5
+
+                tmp3 = []
+                for child in ac:
+                    tmp2 = []
+                    if child.name == "f_add":
+                        if child.children != []:
+                            tmp2.extend(child.children)
+                        else:
+                            tmp2 = [child]
+                    else:
+                        tmp3.append(child)
+                    if tmp2 != []:
+                        addchild.append(tmp2)
+
+                tmp4 = 1
+                for item in tmp3:
+                    tmp4 = tmp4 * item
+                addchild.append([tmp4])
+
+                def flatten(lst):
+                    flat_list = []
+                    for item in lst:
+                        if isinstance(item, list) and item == []:
+                            continue
+                        if isinstance(item, list):
+                            flat_list.extend(flatten(item))
+                        else:
+                            flat_list.append(item)
+                    return flat_list
+
+                if len(flatten(addchild)) > 0:
+                    add = 0
+                    for prod_items in itertools.product(*addchild):
+                        mul = 1
+                        for item2 in prod_items:
+                            mul = mul * item2
+                            mul = simplify(mul)
+                        add = add + mul
+                        add = simplify(add)
+                    current_eq = simplify(add)
                 else:
-                    tmp2 = [child]
+                    current_eq = simplify(current_eq)
+
+                # Store expanded result
+                result_map[node_id] = current_eq
             else:
-                tmp3.append(child)
-            if tmp2 != []:
-                addchild.append(tmp2)
-        tmp4 = 1
-        for item in tmp3:
-            tmp4 = tmp4 * item
-        addchild.append([tmp4])
-        def flatten(lst):
-            flat_list = []
-            for item in lst:
-                if isinstance(item, list) and item == []:
-                    continue
-                if isinstance(item, list):
-                    flat_list.extend(flatten(item))
-                else:
-                    flat_list.append(item)
-            return flat_list
-        
-        if isinstance(addchild, list) and len(flatten(addchild))>0:
-            add= 0
-            for item in itertools.product(*addchild):
-                mul = 1
-                for item2 in item:
-                    mul = mul * item2
-                    mul = simplify(mul)
-                add = add + mul
-                add = simplify(add)
-            eq = add
-        eq = simplify(eq)
-        
-    return TreeNode(eq.name, [expand(child) for child in eq.children])
+                # Default: reconstruct node with children
+                result_map[node_id] = TreeNode(node.name, children_expanded)
+
+    # Return final expanded eq
+    return result_map[id(eq)]
 

mathai/factor.py

@@ -77,7 +77,12 @@ def factor_quad_formula_init():
     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))"),\
@@ -87,8 +92,9 @@ def factor_cube_formula_init():
     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
+    global formula_gen2, formula_gen3, formula_gen9
     maxnum = 1
     def high(eq):
         nonlocal maxnum
@@ -114,6 +120,8 @@ def factor_helper(equation, complexnum, 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:
+        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))
     if out is not None and (complexnum or (not complexnum and not contain(out, tree_form("s_i")))):
@@ -122,4 +130,4 @@ def factor_helper(equation, complexnum, power=2):
 def factor(equation, complexnum=False):
     return solve(take_common2(simplify(factor_helper(simplify(equation), complexnum, 2))))
 def factor2(equation, complexnum=False):
-    return solve(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3))
+    return solve(factor_helper(solve(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3)), complexnum, 4))

mathai/fraction.py

@@ -1,59 +1,103 @@
 from .base import *
-from .simplify import solve
+from .simplify import solve, simplify
 from .expand import expand
+
 def fraction(eq):
-    if eq.name == "f_eq":
-        return TreeNode(eq.name, [fraction(eq.children[0]), fraction(eq.children[1])])
-    if eq.name == "f_add":
-        con = []
-        for child in eq.children:
-            if child.name == "f_pow" and child.children[1].name[:2] == "d_" and int(child.children[1].name[2:])<0:
-                den = []
-                n = int(child.children[1].name[2:])
-                if n == -1:
-                    den.append(child.children[0])
-                else:
-                    den.append(TreeNode("f_pow", [child.children[0], tree_form("d_"+str(-n))]))
-                con.append([[], den])
-            elif child.name == "f_mul":
-                num = []
-                den = []
-                for child2 in child.children:
-                    if child2.name == "f_pow" and child2.children[1].name[:2] == "d_" and int(child2.children[1].name[2:])<0:
-                        n = int(child2.children[1].name[2:])
-                        if n == -1:
-                            den.append(child2.children[0])
+    stack = [(eq, None)]  # (current_node, parent_processed_children)
+    result_map = {}  # Map original nodes to their processed TreeNode
+
+    while stack:
+        node, parent_info = stack.pop()
+
+        # If node already processed, continue
+        if node in result_map:
+            continue
+
+        # Base case: leaf node
+        if not node.children:
+            result_map[node] = TreeNode(node.name, [])
+            continue
+
+        # Check if all children are processed
+        all_children_done = all(child in result_map for child in node.children)
+        if not all_children_done:
+            # Push current node back to stack after children
+            stack.append((node, parent_info))
+            for child in reversed(node.children):
+                if child not in result_map:
+                    stack.append((child, (node, node.children)))
+            continue
+
+        # Now all children are processed, handle this node
+        if node.name == "f_eq":
+            left = result_map[node.children[0]]
+            right = result_map[node.children[1]]
+            result_map[node] = TreeNode("f_eq", [left, right])
+            continue
+
+        elif node.name == "f_add":
+            con = []
+            for child in node.children:
+                child_processed = result_map[child]
+                if child_processed.name == "f_pow" and child_processed.children[1].name[:2] == "d_" and int(child_processed.children[1].name[2:]) < 0:
+                    den = []
+                    n = int(child_processed.children[1].name[2:])
+                    if n == -1:
+                        den.append(child_processed.children[0])
+                    else:
+                        den.append(TreeNode("f_pow", [child_processed.children[0], tree_form("d_" + str(-n))]))
+                    con.append([[], den])
+                elif child_processed.name == "f_mul":
+                    num = []
+                    den = []
+                    for child2 in child_processed.children:
+                        if child2.name == "f_pow" and child2.children[1].name[:2] == "d_" and int(child2.children[1].name[2:]) < 0:
+                            n = int(child2.children[1].name[2:])
+                            if n == -1:
+                                den.append(child2.children[0])
+                            else:
+                                den.append(TreeNode("f_pow", [child2.children[0], tree_form("d_" + str(-n))]))
                         else:
-                            den.append(TreeNode("f_pow", [child2.children[0], tree_form("d_"+str(-n))]))
+                            num.append(child2)
+                    con.append([num, den])
+                else:
+                    con.append([[child_processed], []])
+
+            if len(con) > 1 and any(x[1] != [] for x in con):
+                # Construct numerator
+                a_children = []
+                for i in range(len(con)):
+                    b_children = con[i][0].copy()
+                    for j in range(len(con)):
+                        if i == j:
+                            continue
+                        b_children += con[j][1]
+                    if len(b_children) == 0:
+                        b_children = [tree_form("d_1")]
+                    elif len(b_children) == 1:
+                        b_children = b_children
                     else:
-                        num.append(child2)
-                con.append([num, den])
-            else:
-                con.append([[child], []])
-        if len(con)>1 and any(x[1] != [] for x in con):
-            a = TreeNode("f_add", [])
-            for i in range(len(con)):
-                b = TreeNode("f_mul", [])
-                if con[i][0] != []:
-                    b.children += con[i][0]
-                for j in range(len(con)):
-                    if i ==j:
-                        continue
-                    b.children +=  con[j][1]
-                if len(b.children) == 1:
-                    a.children.append(b.children[0])
-                elif len(b.children) > 1:
-                    a.children.append(b)
+                        b_children = [TreeNode("f_mul", b_children)]
+                    a_children += b_children if isinstance(b_children, list) else [b_children]
+
+                a = TreeNode("f_add", a_children)
+
+                # Construct denominator
+                c_children = []
+                for i in range(len(con)):
+                    c_children += con[i][1]
+                if len(c_children) == 1:
+                    c = c_children[0]
                 else:
-                    a.children.append(tree_form("d_1"))
-            c = TreeNode("f_mul", [])
-            for i in range(len(con)):
-                c.children += con[i][1]
-            if len(c.children)==1:
-                c = c.children[0]
-            c = TreeNode("f_pow", [c, tree_form("d_-1")])
-            return TreeNode("f_mul", [expand(a),c])
-    arr = TreeNode(eq.name, [])
-    for child in eq.children:
-        arr.children.append(fraction(child))
-    return solve(arr)
+                    c = TreeNode("f_mul", c_children)
+                c = TreeNode("f_pow", [c, tree_form("d_-1")])
+
+                result_map[node] = TreeNode("f_mul", [simplify(expand(a)), c])
+                continue
+
+        # Default: just reconstruct node
+        children_processed = [result_map[child] for child in node.children]
+        result_map[node] = TreeNode(node.name, children_processed)
+
+    # Final return
+    return solve(result_map[eq])