mathai 0.7.7__py3-none-any.whl → 0.7.9__py3-none-any.whl

mathai/__init__.py

@@ -1,7 +1,7 @@
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 
-from .pde import pde_sep, want
+from .pde import pde_sep, want, absorb
 
 from .linear import linear_solve, linear_or
 
@@ -21,7 +21,7 @@ from .integrate import rm_const as integrate_const
 from .integrate import solve_integrate as integrate_clean
 from .integrate import integrate_formula
 
-from .diff import diff
+from .diff import diff, diff2
 
 from .factor import factor as factor1
 from .factor import factor2, factor3

mathai/base.py

@@ -14,7 +14,6 @@ def contains_list_or_neg(node):
     return False
 
 class TreeNode:
-    matmul = None
     
     def __init__(self, name, children=None):
         if children is None:

mathai/diff.py

@@ -1,6 +1,87 @@
+from .trig import trig0
 from .simplify import simplify
 from .base import *
-from .trig import trig0
+
+def helper(eq):
+    name = eq.name
+    if name in ["f_dif", "f_pdif"]:
+        if eq.children[0].name == "f_add":
+            return summation([TreeNode(name, [child, eq.children[1]]) for child in eq.children[0].children])
+        
+        if eq.children[0].name == "f_mul":
+            return summation([product([TreeNode(name, [child, eq.children[1]]) if index==index2 else child for index2, child in enumerate(eq.children[0].children)])\
+                              for index in range(len(eq.children[0].children))])
+        if eq.children[0].name == "f_pow" and "v_" not in str_form(eq.children[0].children[1]):
+            base, power = eq.children[0].children
+            dbase = TreeNode(name, [base, eq.children[1]])
+            b1 = power - tree_form("d_1")
+            bab1 = TreeNode("f_pow", [base, b1])
+            return power * bab1 * dbase
+        
+        if eq.children[0].name == "f_pow":
+            a, b = eq.children
+            return a**b * ((b/a) * TreeNode(name, [a, eq.children[1]]) + a.fx("log") * TreeNode(name, [b, eq.children[1]]))
+
+        if "v_" not in str_form(eq.children[0]):
+            return tree_form("d_0")
+        
+        if eq.children[0] == eq.children[1]:
+            return tree_form("d_1")
+        
+        if name == "f_pdif" and not contain(eq.children[0], eq.children[1]):
+            return tree_form("d_0")
+        if eq.children[0].name == "f_sin":
+            eq.children[0].name = "f_cos"
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d*eq.children[0]
+        if eq.children[0].name == "f_cos":
+            eq.children[0].name = "f_sin"
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return tree_form("d_-1")*d*eq.children[0]
+        if eq.children[0].name == "f_tan":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d/(eq.children[0].children[0].fx("cos")*eq.children[0].children[0].fx("cos"))
+        if eq.children[0].name == "f_log":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d*(tree_form("d_1")/eq.children[0].children[0])
+        if eq.children[0].name == "f_arcsin":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d/(tree_form("d_1")-eq.children[0].children[0]*eq.children[0].children[0])**(tree_form("d_2")**-1)
+        if eq.children[0].name == "f_arccos":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return tree_form("d_-1")*d/(tree_form("d_1")-eq.children[0].children[0]*eq.children[0].children[0])**(tree_form("d_2")**-1)
+        if eq.children[0].name == "f_arctan":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d/(tree_form("d_1")+eq.children[0].children[0]*eq.children[0].children[0])
+        
+    return eq
+
+def diff3(eq):
+    eq = simplify(eq)
+
+    stack = [(eq, False)]
+    out = {}
+
+    while stack:
+        node, visited = stack.pop()
+
+        if not visited:
+            stack.append((node, True))
+            for c in node.children:
+                stack.append((c, False))
+            continue
+
+        new_children = [out[c] for c in node.children]
+        rebuilt = TreeNode(node.name, new_children)
+        rebuilt = helper(rebuilt)
+        rebuilt = simplify(rebuilt)
+
+        out[node] = rebuilt
+
+    return out[eq]
+
+def diff2(eq):
+    return dowhile(eq, diff3)
 def diff(equation, var="v_0"):
     def diffeq(eq):
         eq = simplify(eq)
@@ -54,7 +135,7 @@ def diff(equation, var="v_0"):
             bab1 = TreeNode("f_pow", [base, b1])
             return power * bab1 * dbase
         return TreeNode("f_dif", [eq, tree_form(var)])
-    def helper(equation, var="v_0"):
+    def helper2(equation, var="v_0"):
         if equation.name == "f_dif":
             if equation.children[0].name == var:
                 return tree_form("d_1")
@@ -62,7 +143,7 @@ def diff(equation, var="v_0"):
                 return tree_form("d_0")
             else:
                 return equation
-        return TreeNode(equation.name, [helper(child, var) for child in equation.children])
+        return TreeNode(equation.name, [helper2(child, var) for child in equation.children])
     def calc(eq):
         if eq.name == "f_dif":
             return diffeq(trig0(eq.children[0]))
@@ -70,5 +151,6 @@ def diff(equation, var="v_0"):
     if var is None:
         return simplify(calc(equation))
     equation = diffeq(trig0(equation))
-    equation = helper(equation, var)
+    equation = helper2(equation, var)
     return simplify(equation)
+

mathai/fraction.py

@@ -2,102 +2,105 @@ from .base import *
 from .simplify import simplify
 from .expand import expand
 
-def fraction(eq):
-    stack = [(eq, None)]  # (current_node, parent_processed_children)
-    result_map = {}  # Map original nodes to their processed TreeNode
 
-    while stack:
-        node, parent_info = stack.pop()
+def fraction(expr):
+    if expr is None:
+        return None
+    
+    expr = simplify(expr)
+    
+    # -----------------------------
+    # leaf
+    # -----------------------------
+    if expr.children == []:
+        return expr
 
-        # If node already processed, continue
-        if node in result_map:
-            continue
+    # recurse first (inner-most first)
+    children = [fraction(c) for c in expr.children]
 
-        # Base case: leaf node
-        if not node.children:
-            result_map[node] = TreeNode(node.name, [])
-            continue
+    # -----------------------------
+    # ADDITION: collect denominators
+    # -----------------------------
+    if expr.name == "f_add":
+        terms = []
 
-        # 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
+        for c in children:
+            # term is a multiplication
+            if c.name == "f_mul":
+                num = []
+                den = []
+                for f in c.children:
+                    if (
+                        f.name == "f_pow"
+                        and f.children[1].name.startswith("d_")
+                        and int(f.children[1].name[2:]) < 0
+                    ):
+                        n = int(f.children[1].name[2:])
+                        den.append(
+                            f.children[0]
+                            if n == -1
+                            else TreeNode("f_pow", [f.children[0], tree_form(f"d_{-n}")])
+                        )
+                    else:
+                        num.append(f)
+                terms.append((num, den))
 
-        # 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
+            # pure reciprocal
+            elif (
+                c.name == "f_pow"
+                and c.children[1].name.startswith("d_")
+                and int(c.children[1].name[2:]) < 0
+            ):
+                n = int(c.children[1].name[2:])
+                terms.append(([], [
+                    c.children[0]
+                    if n == -1
+                    else TreeNode("f_pow", [c.children[0], tree_form(f"d_{-n}")])
+                ]))
 
-        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:
-                            num.append(child2)
-                    con.append([num, den])
-                else:
-                    con.append([[child_processed], []])
+            # normal term
+            else:
+                terms.append(([c], []))
 
-            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:
-                        b_children = [TreeNode("f_mul", b_children)]
-                    a_children += b_children if isinstance(b_children, list) else [b_children]
+        # if no denominators → rebuild normally
+        if not any(den for _, den in terms):
+            return TreeNode("f_add", children)
 
-                a = TreeNode("f_add", a_children)
+        # -----------------------------
+        # build numerator
+        # -----------------------------
+        num_terms = []
+        for i, (num_i, _) in enumerate(terms):
+            acc = list(num_i)
+            for j, (_, den_j) in enumerate(terms):
+                if i != j:
+                    acc += den_j
+            if not acc:
+                acc = [tree_form("d_1")]
+            num_terms.append(
+                acc[0] if len(acc) == 1 else TreeNode("f_mul", acc)
+            )
 
-                # 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:
-                    c = TreeNode("f_mul", c_children)
-                c = TreeNode("f_pow", [c, tree_form("d_-1")])
+        numerator = TreeNode("f_add", num_terms)
 
-                result_map[node] = TreeNode("f_mul", [simplify(expand(simplify(a))), c])
-                continue
+        # -----------------------------
+        # build denominator
+        # -----------------------------
+        den_all = []
+        for _, den in terms:
+            den_all += den
 
-        # Default: just reconstruct node
-        children_processed = [result_map[child] for child in node.children]
-        result_map[node] = TreeNode(node.name, children_processed)
+        denom = den_all[0] if len(den_all) == 1 else TreeNode("f_mul", den_all)
+        denom = TreeNode("f_pow", [denom, tree_form("d_-1")])
+        
+        return simplify(
+            TreeNode(
+                "f_mul",
+                [simplify(expand(numerator)), denom],
+            )
+        )
 
-    # Final return
-    return simplify(result_map[eq])
+    # -----------------------------
+    # default reconstruction
+    # -----------------------------
+    return TreeNode(expr.name, children)

mathai/integrate.py

@@ -97,6 +97,8 @@ def place_try2(eq):
         return eq.children[try_lst.pop(0)]
     return TreeNode(eq.name, [place_try2(child) for child in eq.children]) 
 def _solve_integrate(eq):
+    if eq is None:
+        return None
     if eq.name == "f_ref":
         return eq
     if eq.name == "f_subs":
@@ -153,14 +155,18 @@ def inteq(eq):
     else:
         return TreeNode(eq.name, [inteq(child) for child in eq.children])
 def rm(eq):
+    if eq is None:
+        return None
     if eq.name == "f_try":
         eq = TreeNode(eq.name, list(set(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 = dowhile(eq2, handle_try)
     eq2 = rm(eq2)
+    if eq2 is None:
+        return None
     if eq2.name == "f_try":
         eq2.children = list(set(eq2.children))
     return eq2
@@ -409,8 +415,8 @@ def integration_formula_ex():
 
 formula_gen11 = integration_formula_ex()
 def rm_const(equation):
-    if equation.name == "f_ref":
-        return equation
+    if equation is None:
+        return None
     eq2 = equation
     if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
@@ -436,8 +442,8 @@ def shorten(eq):
         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()
+    if equation is None:
+        return None
     eq2 = equation.copy_tree()
     if eq2.name == "f_integrate":
         integrand = eq2.children[0]

mathai/ode.py

@@ -1,54 +1,120 @@
+import itertools
 from collections import Counter
-from .diff import diff
-from .factor import factor
+from .diff import diff, diff2
+from .factor import factor, factor2, term_common2
 from .expand import expand
 from .base import *
 from .fraction import fraction
 from .simplify import simplify
 import copy
+from .inverse import inverse
+from .parser import parse
 
+def rev(eq):
+    tmp = factor_generation(eq)
+    if tree_form("v_0").fx("dif")**-1 in tmp or tree_form("v_1").fx("dif")**-1 in  tmp:
+        return False
+    for child in eq.children:
+        if not rev(child):
+            return False
+    return True
+node_count = 100
+def kkk(lhs, rhs, depth=5):
+    global node_count
+    lst = [simplify(lhs), simplify(rhs)]
+    orig = copy.deepcopy(lst)
+    if not contain(lst[0], tree_form("v_1")) and not contain(lst[1], tree_form("v_0")):
+        if not contain(lst[0], tree_form("v_0")) and not contain(lst[1], tree_form("v_1")):
+            return lst, False
+        return lst, True
+    node_count -= 1
+    
+    if depth < 0 or node_count < 0:
+        return lst, False
+    for j in range(2):
+        for i in range(2):
+            if lst[i].name in ["f_mul", "f_add"]:
+                for child in lst[i].children:
+                    out = child
+                    if j == 0:
+                        if contain(out, tree_form(f"v_{i}")) or not contain(out, tree_form(f"v_{1-i}")):
+                            continue
+                    if contain(out, tree_form(f"v_{i}")) and not contain(out, tree_form(f"v_{1-i}")):
+                        continue
+                    
+                    if lst[i].name == "f_add":
+                        lst[i] = lst[i] - out
+                        lst[1-i] = lst[1-i] - out
+                    elif lst[i].name == "f_mul":
+                        lst[i] = lst[i] / out
+                        lst[1-i] = lst[1-i] / out
+                    else:
+                        continue
+                    
+                    output = kkk(lst[0], lst[1], depth-1)
+                    lst = orig
+                    
+                    if output[1]:
+                        return output
+                
+    return lst, False
+def clr(eq):
+    return simplify(product([item for item in factor_generation(eq) if "f_add" in str_form(item)]))
 def inversediff(lhs, rhs):
-    count = 5
-    while contain(rhs, tree_form("v_1")) or contain(lhs, tree_form("v_0")):
-        success = False
-        if rhs.name == "f_add":
-            for i in range(len(rhs.children)-1,-1,-1):
-                if not contain(rhs.children[i], tree_form("v_0")) or str_form(tree_form("v_1").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
-                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
-                        success = True
-                    lhs = lhs - rhs.children[i]
-                    rhs.children.pop(i)
-        elif rhs.name == "f_mul":
-            for i in range(len(rhs.children)-1,-1,-1):
-                if not contain(rhs.children[i], tree_form("v_0")):
-                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
-                        success = True
-                    lhs = lhs / rhs.children[i]
-                    rhs.children.pop(i)
-        if len(rhs.children) == 1:
-            rhs = rhs.children[0]
-        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
-        if rhs.name == "f_add":
-            for i in range(len(rhs.children)-1,-1,-1):
-                if not contain(rhs.children[i], tree_form("v_1")) or str_form(tree_form("v_0").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
-                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
-                        success = True
-                    lhs = lhs - rhs.children[i]
-                    rhs.children.pop(i)
-        elif rhs.name == "f_mul":
-            for i in range(len(rhs.children)-1,-1,-1):
-                if not contain(rhs.children[i], tree_form("v_1")):
-                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
-                        success = True
-                    lhs = lhs / rhs.children[i]
-                    rhs.children.pop(i)
-        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
-        if not success:
-            lhs, rhs = factor(lhs),factor(rhs)
-        count -= 1
-        if count == 0:
-            return simplify(e0(lhs-rhs))
-    return simplify(e0(lhs-rhs))
+    global node_count
+    eq = simplify(fraction(TreeNode("f_eq", [lhs-rhs, tree_form("d_0")]))).children[0]
+    eq = simplify(term_common2(eq))
+    eq = clr(eq)
+    
+    out= None
+    if eq.name == "f_add":
+        h = {}
+        n = [eq]
+        for i in range(len(eq.children)-2,1,-1):
+            for item in itertools.combinations(list(range(len(eq.children))), i):
+                item = tuple(sorted(list(item)))
+                tmp = simplify(term_common2(simplify(summation([eq.children[x] for x in item]))))
+                if tmp.name == "f_mul":
+                    h[item] = tmp
+                    
+        for item in itertools.combinations(list(h.keys()),2):
+            
+            g = []
+            for x in item:
+                g += x
+            if sum([len(x) for x in item]) == len(set(g)):
+                pass
+            else:
+                continue
+            
+            item2 = summation([eq.children[x] for x in list(set(range(len(eq.children)))-set(g))])
+            n.append(simplify(term_common2(simplify(h[item[0]] + h[item[1]]))+item2))
+                
+        
+        for item in list(set(n)):
+            
+            item = clr(item)
+            node_count = 100
+            
+            tmp = kkk(item, tree_form("d_0"))
+            
+            if tmp[1]:
+                out = tmp[0]
+                break
+    else:
+        node_count = 100
+        tmp = kkk(eq, tree_form("d_0"))
+        if tmp[1]:
+            out = tmp[0]
+    if out is None:
+        return None
+    out = [simplify(fraction(item)) for item in out]
+    
+    if not rev(out[0]) and not rev(out[1]):
+        
+        out[0] = fraction(1/out[0])
+        out[1] = fraction(1/out[1])
+    return simplify(e0(out[0]-out[1]))
 
 def allocvar():
     return tree_form("v_101")
@@ -62,38 +128,28 @@ def esolve(s):
         return product([tree_form("s_e")**child for child in s.children]) - tree_form("d_1")
     return TreeNode(s.name, [esolve(child) for child in s.children])
 def diffsolve_sep2(eq):
-    global tab
-    
-    s = []
-    eq = simplify(expand(eq))
-    eq = e1(eq)
-    
-    def vlor1(eq):
-        if contain(eq, tree_form("v_0")) and not contain(eq, tree_form("v_1")):
-            return True
-        if contain(eq, tree_form("v_1")) and not contain(eq, tree_form("v_0")):
-            return True
-        return False
-    if eq.name == "f_add" and all(vlor1(child) and [str_form(x) for x in factor_generation(copy.deepcopy(child))].count(str_form(tree_form(vlist(child)[0]).fx("dif")))==1 for child in eq.children):
-        for child in eq.children:
-            v = vlist(child)[0]
-            v2 = tree_form(v).fx("dif")
-            child = replace(child, v2, tree_form("d_1"))
-            child = simplify(child)
-            
-            
-            tmp6 = TreeNode("f_integrate", [child, tree_form(v)])
-            s.append(tmp6)
-            
-            if s[-1] is None:
-                return None
-        s.append(allocvar())
-    else:
+    lst = None
+    if eq is None:
         return None
-    s = summation(s)
-    s = simplify(e0(s))
+    eq = eq.children[0]
+    if eq.name == "f_add":
+        lst = list(eq.children)
+    else:
+        lst = [eq]
+    s = [allocvar()]
+    
+    for item in lst:
+        item = simplify(item)
+        tmp = factor_generation(item)
+        
+        tmp2 = product([k for k in tmp if k.name != "f_dif"])
+        
+        if tree_form("v_0").fx("dif") in tmp:
+            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_0")]))
+        elif tree_form("v_1").fx("dif") in tmp:
+            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_1")]))
     
-    return groupe(s)
+    return TreeNode("f_eq", [summation(s), tree_form("d_0")])
 def e0(eq):
     return TreeNode("f_eq", [eq, tree_form("d_0")])
 def e1(eq):
@@ -110,58 +166,85 @@ def groupe(eq):
 
 def diffsolve_sep(eq):
     eq = epowersplit(eq)
-
+    
     eq = inversediff(tree_form("d_0"), eq.children[0].copy_tree())
+    
     return eq
 
 def diffsolve(eq):
     orig = eq.copy_tree()
-
+    eq = diff2(eq)
+    eq = subs2(eq, order(eq))
+    eq = fraction(simplify(fraction(eq)))
+    
+    if order(eq) == 2:
+        for i in range(2):
+            out = second_order_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
+            if out is not None:
+                return out
+        return orig
     
     eq = diffsolve_sep2(diffsolve_sep(eq))
+    
     if eq is None:
         for i in range(2):
             a = tree_form(f"v_{i}")
             b = tree_form(f"v_{1-i}")
             c = tree_form("v_2")
-            eq2 = replace(orig, b,b*a)
-            eq2 = expand(simplify(fraction(simplify(diff(eq2, None)))))
+            eq2 = orig
+            
+            eq2 = subs2(eq2, 1)
+            eq2 = replace(eq2, b, b*a)
+            eq2 = subs3(eq2)
+            
+            eq2 = simplify(fraction(simplify(eq2)))
+            
             eq2 = diffsolve_sep(eq2)
+            
             eq2 = diffsolve_sep2(eq2)
             if eq2 is not None:
                 return e0(TreeNode("f_subs", [replace(eq2.children[0],b,c), c,b/a]).fx("try"))
         eq = orig
-    
-    eq = fraction(eq)
-    eq = simplify(eq)
-    for i in range(2):
-        out = linear_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
-        if out is not None:
-            return out
-    return eq
+        eq = simplify(eq)
+        eq = subs2(eq, 1)
+        eq = fraction(eq)
+        for i in range(2):
+            
+            out = linear_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
+            if out is not None:
+                return out
+        return orig
+    else:
+        return eq
+
 def clist(x):
     return list(x.elements())
 def collect_term(eq, term_lst):
     
     lst = None
     if eq.name == "f_add":
-        lst = eq.children
+        lst = copy.deepcopy(eq.children)
     else:
         lst = [eq]
         
     other = []
     dic = {}
-    term_lst = sorted(term_lst, key=lambda x: -len(factor_generation(x)))
+    term_lst = list(sorted(term_lst, key=lambda x: -len(factor_generation(x))))
+    for item in term_lst:
+        dic[item] = tree_form("d_0")
     for item2 in lst:
         done = True
         tmp2 = Counter(factor_generation(item2))
         for index, item in enumerate(term_lst):
+            
             tmp = Counter(factor_generation(item))
             
-            if (tmp2&tmp) == tmp and clist((tmp2 - tmp)&tmp)==[]:
+            if (tmp2&tmp) == tmp:
                 if item in dic.keys():
+                    
                     dic[item] += product(clist(tmp2-tmp))
                 else:
+                    
                     dic[item] = product(clist(tmp2-tmp))
                 done = False
                 break
@@ -172,8 +255,61 @@ def collect_term(eq, term_lst):
     for key in dic.keys():
         dic[key] = simplify(dic[key])
     return [dic, simplify(other)]
+def order(eq,m=0):
+    best = m
+    if eq.name in ["f_pdif", "f_dif"]:
+        out = order(eq.children[0], m+1)
+        best = max(out, best)
+    else:
+        for child in eq.children:
+            out = order(child, m)
+            best = max(out, best)
+    return best
+def subs2(eq, orde):
+    if eq.name in ["f_dif", "f_pdif"] and len(eq.children) == 2:
+        if orde == 1:
+            return eq.children[0].fx("dif")/eq.children[1].fx("dif")
+        else:
+            return subs2(TreeNode("f_dif", eq.children), orde)
+    return TreeNode(eq.name, [subs2(child, orde) for child in eq.children])
+def subs3(eq):
+    if eq.name == "f_dif" and eq.children[0].name == "f_add":
+        return summation([subs3(child.fx("dif")) for child in eq.children[0].children])
+    if eq.name == "f_dif" and eq.children[0].name == "f_mul":
+        return summation([product([subs3(child.fx("dif")) if index==index2 else child for index2, child in enumerate(eq.children[0].children)]) for index in range(len(eq.children[0].children))])
+    return TreeNode(eq.name, [subs3(child) for child in eq.children])
+def second_order_dif(eq, a, b):
+    eq = simplify(eq)
+    nn = [TreeNode("f_dif", [TreeNode("f_dif", [b,a]),a]), TreeNode("f_dif", [b,a]), b]
+    out = collect_term(eq.children[0], nn)
+    if out[1] == tree_form("d_0"):
+        tmp = out[0][nn[0]]
+        if tmp != tree_form("d_0"):
+            for key in out[0].keys():
+                out[0][key] = simplify(out[0][key]/tmp)
+                
+            B = out[0][nn[1]]
+            C = out[0][nn[2]]
+            
+            if all(all(not contain(item, item2) for item2 in [a,b]) for item in [B, C]):
+                r = parse("r")
+                s = simplify(factor2(simplify(TreeNode("f_eq", [r**2 + B*r + C, tree_form("d_0")])), True))
+                r1, r2 = [inverse(item, r.name) for item in s.children[0].children]
+                out = None
+                if contain(r1, tree_form("s_i")):
+                    real = simplify(fraction((r1+r2)/tree_form("d_2")))
+                    imagine = simplify((r1-real)/tree_form("s_i"))
+                    out = tree_form("s_e")**(real*a)*(tree_form("v_101")*(imagine*a).fx("cos")+tree_form("v_102")*(imagine*a).fx("sin"))
+                elif fraction(simplify(r1-r2)) == tree_form("d_0"):
+                    out =(tree_form("v_101")+tree_form("v_102")*a)*tree_form("s_e")**(r1*a)
+                else:
+                    out = tree_form("v_101")*tree_form("s_e")**(r1*a) + tree_form("v_102")*tree_form("s_e")**(r2*a)
+                return TreeNode("f_eq", [b, out])
+    return None
+                
 def linear_dif(eq, a, b):
     eq = simplify(eq)
+    
     out = collect_term(eq.children[0], [b.fx("dif"), b*a.fx("dif"), a.fx("dif")])
     
     if out[1] == tree_form("d_0"):
@@ -183,7 +319,8 @@ def linear_dif(eq, a, b):
             for key in out[0].keys():
                 out[0][key] = simplify(out[0][key]/tmp)
             p, q = out[0][b*a.fx("dif")], -out[0][a.fx("dif")]
-            
+            if contain(p, b) or contain(q, b):
+                return None
             f = tree_form("s_e") ** TreeNode("f_integrate", [p, a])
             return simplify(TreeNode("f_eq", [b*f, TreeNode("f_integrate", [q*f, a])+allocvar()]))
     return None

mathai/parser.py

@@ -60,7 +60,7 @@ grammar = """
      | ESCAPED_STRING      -> string
      | CAPITAL_ID          -> matrix
 
-FUNC_NAME: "midpoint" | "ref" | "expect" | "covariance" | "variance" | "subs" | "try" | "limit" | "forall" | "limitpinf" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
+FUNC_NAME: "midpoint" | "ref" | "expect" | "U" | "covariance" | "variance" | "subs" | "try" | "limit" | "forall" | "limitpinf" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
 
 VARIABLE: /[a-z]/ | "nabla" | "pi" | "kc" | "hbar" | "em" | "ec" | "anot" | "false" | "true"
 
@@ -131,7 +131,7 @@ def parse(equation, funclist=None):
         if tree_node.name == "pass_through":
             return fxchange(tree_node.children[0])
         return TreeNode(
-            "f_" + tree_node.name if tree_node.name in tmp3 + ["limitpinf", "limit", "try", "ref", "sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul", "cross", "wmul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
+            "f_" + tree_node.name if tree_node.name in tmp3 + ["U", "limitpinf", "limit", "try", "ref", "sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul", "cross", "wmul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
             [fxchange(child) for child in tree_node.children]
         )
 
@@ -155,5 +155,4 @@ def parse(equation, funclist=None):
         return tree_node
     
     tree_node = rfx(tree_node)
-    tree_node = flatten_tree(tree_node)
     return tree_node

mathai/pde.py

@@ -1,89 +1,22 @@
-from .ode import diffsolve
+from .expand import expand
+from .ode import diffsolve, inversediff, order, groupe, epowersplit, subs2
 from .base import *
 from .simplify import simplify
-from .diff import diff
+from .diff import diff2
 from .fraction import fraction
 from .parser import parse
 from .inverse import inverse
+from .factor import factor
+
 def capital2(eq):
-    if eq.name == "f_pdif":
+    if eq.name == "f_pdif" and eq.children[0].name != "f_pdif":
         return eq.children[0]
     for child in eq.children:
         out = capital2(child)
         if out is not None:
             return out
     return None
-def subs(eq, r2):
-    if eq.name == "f_dif":
-        return TreeNode("f_pdif", eq.children)
-    if eq == r2:
-       return parse("x").fx("X") * parse("y").fx("Y")
-    if eq.name == "f_pdif":
-        return subs(diff(subs(eq.children[0], r2), str_form(eq.children[1])), r2)
-    return TreeNode(eq.name, [subs(child, r2) for child in eq.children])
-def inverse_pde(lhs, rhs, depth=3):
-    if depth < 0:
-        return None
-    
-    lhs = simplify(lhs.copy_tree())
-    rhs = simplify(rhs.copy_tree())
-    
-    # separation check: lhs has no y, rhs has no x
-    lhs_str = str_form(lhs)
-    rhs_str = str_form(rhs)
-
-    if "v_1" not in lhs_str and "v_0" not in rhs_str:
-        return [lhs, rhs]
-
-    sides = [lhs, rhs]
-
-    for side in range(2):
-        eq = sides[side]
-
-        if eq.name not in ("f_add", "f_mul"):
-            continue
-
-        # iterate over a COPY — never mutate while iterating
-        for i, child in enumerate(eq.children.copy()):
-            # rebuild remaining expression safely
-            rest_children = [
-                c.copy_tree()
-                for j, c in enumerate(eq.children)
-                if j != i
-            ]
-
-            if not rest_children:
-                continue
 
-            if len(rest_children) == 1:
-                rest = rest_children[0]
-            else:
-                rest = TreeNode(eq.name, rest_children)
-
-            other = sides[1 - side].copy_tree()
-
-            # move term across
-            if eq.name == "f_add":
-                moved = TreeNode("f_add", [other, -child.copy_tree()])
-            else:  # f_mul
-                moved = TreeNode("f_mul", [other, TreeNode("f_pow", [child.copy_tree(), tree_form("d_-1")])])
-
-            moved = simplify(moved)
-            rest = simplify(rest)
-
-            if side == 0:
-                out = inverse_pde(rest, moved, depth - 1)
-            else:
-                out = inverse_pde(moved, rest, depth - 1)
-
-            if out is not None:
-                return out
-
-    return None
-def subs2(eq):
-    if eq.name == "f_pdif":
-        return eq.children[0].fx("dif")/eq.children[1].fx("dif")
-    return TreeNode(eq.name, [subs2(child) for child in eq.children])
 def capital(eq):
     if eq.name[:2] == "f_" and eq.name != eq.name.lower():
         return eq
@@ -97,13 +30,17 @@ def abs_const(eq):
         return tree_form("v_101")*eq.children[0]
     return TreeNode(eq.name, [abs_const(child) for child in eq.children])
 def want(eq):
+    if eq is None:
+        return None
     if eq.name == "f_want":
+        
         eq2 = eq.children[0]
         v = [tree_form(item) for item in vlist(eq.children[0])]
         lst = {}
         if eq.children[1].name == "f_and":
             for item in eq.children[1].children:
                 item = abs_const(item)
+                item = groupe(item)
                 for item2 in v:
                     if contain(item, item2):
                         out = inverse(item.children[0], str_form(item2))
@@ -113,26 +50,50 @@ def want(eq):
         for key in lst.keys():
             eq2 = replace(eq2, key, lst[key])
         if len(lst.keys()) == len(v):
-            return simplify(eq2)
+            return fraction(groupe(simplify(eq2)))
     return TreeNode(eq.name, [want(child) for child in eq.children])
+def absorb2(eq):
+    if "v_103" in vlist(eq):
+        v = vlist(eq)
+        v.remove("v_103")
+        if set(v)<set(["v_101", "v_102"]):
+            return tree_form("v_103")
+    if ["v_101"] == vlist(eq):
+        return tree_form("v_101")
+    if ["v_102"] == vlist(eq):
+        return tree_form("v_102")
+    if ["v_103"] == vlist(eq):
+        return tree_form("v_103")
+    return TreeNode(eq.name, [absorb2(child) for child in eq.children])
+def absorb(eq):
+    return dowhile(epowersplit(eq), absorb2)
 def pde_sep(eq):
     if eq.name == "f_eq":
         eq = eq.children[0]
-    r2 = capital2(eq)
+    r2 = parse("U(x,y)")
+    eq = replace(eq, r2, parse("x").fx("X") * parse("y").fx("Y"))
+
+    eq =  fraction(simplify(fraction(TreeNode("f_eq", [diff2(eq), tree_form("d_0")]))))
+    
+    out = inversediff(eq.children[0], tree_form("d_0"))
     
-    eq =  simplify(fraction(subs(eq, r2)))
-    out = inverse_pde(eq,tree_form("d_0"))
     if out is not None:
-        out = list(out)
+        out = list(out.children[0].children)
+        if contain(out[0], tree_form("v_1")):
+            out = out[::-1]
+        out[0] = simplify(-out[0])
+        
         lst = []
         for i in range(2):
-            out[i] = subs2(out[i])
-            out[i] = TreeNode("f_eq", [out[i], tree_form("v_102")])
+            
+            out[i] = TreeNode("f_eq", [out[i], tree_form("v_103")])
             out[i] = fraction(simplify(out[i]))
             r = capital(out[i])
             lst.append(r)
             out[i] = replace(out[i], r, tree_form(f"v_{1-i}"))
+            out[i] = tree_form(str_form(out[i]).replace("f_pdif", "f_dif"))
             out[i] = diffsolve(out[i])
+            
             out[i] = replace(out[i], tree_form(f"v_{1-i}"), r)
         out = TreeNode("f_eq", [r2, TreeNode("f_want", [product(lst), TreeNode("f_and", out)])])
         return replace(replace(out, lst[0], parse("a")), lst[1], parse("b"))

mathai/structure.py

@@ -2,7 +2,7 @@ import itertools
 from .simplify import simplify
 from .base import *
 
-def structure(equation, formula, formula_out=None, only_const=False):
+def structure(equation, formula, formula_out=None, only_const=False, wrt=None):
     varlist = {}
     def helper(equation, formula):
         nonlocal varlist
@@ -60,7 +60,7 @@ def structure(equation, formula, formula_out=None, only_const=False):
     for item in lst(formula):
         varlist = {}
         if helper(equation, item):
-            if only_const and any("v_" in str_form(varlist[key]) for key in varlist.keys()):
+            if only_const and any(contain(varlist[key], tree_form(wrt)) for key in varlist.keys()):
                 continue
             if formula_out is None:
                 return varlist
@@ -90,7 +90,7 @@ def transform_formula(equation, wrt, formula_list, var, expr):
             if var != "":
                 p = True
             try:
-                out = structure(equation.copy_tree(), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p)
+                out = structure(equation.copy_tree(), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p, wrt)
                 if out is not None:
                     out = simplify(out)
                     

{mathai-0.7.7.dist-info → mathai-0.7.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.7.7
+Version: 0.7.9
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Requires-Python: >=3.7

{mathai-0.7.7.dist-info → mathai-0.7.9.dist-info}/RECORD

@@ -1,30 +1,30 @@
-mathai/__init__.py,sha256=XkmMsqLr7MkYu1lMwwgsiEagtuOK_KsxLTbAHXgYSmo,1510
+mathai/__init__.py,sha256=JdRPSes54qhzvi6f8Rni2sXljzzirrWZsaCmu9W9rws,1525
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=LdIpxwqhqjL-O7GTfzyzCNN5_Zibp6dNZQVD42SwfIw,14862
+mathai/base.py,sha256=zha7eOnfLjJuQcwi29rE0588U1R8v-0zulVPatr2aQo,14843
 mathai/bivariate_inequality.py,sha256=Da-A1kqVynR0tNOlEI7GSTf5T2vNkcF4etL9-EoyPJg,11415
 mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
-mathai/diff.py,sha256=3__PoEqs_JlS2fRkebXyL-7eyV69ZoV8vCjpYgDWcXE,3297
+mathai/diff.py,sha256=GEiAGMCTT0dO-ULTUGvTlBKy-Io-r2xcgvFJfmqGurY,6879
 mathai/expand.py,sha256=IuzMX6emCT480VE27aCtR0eWU-rJ2VElvRLVa2xcRw0,2582
 mathai/factor.py,sha256=mz_UlPuAqwvsextLB0FM5KWIuuDiMMKG51bXrofqzw8,12830
-mathai/fraction.py,sha256=3Qer3K20ZO2exMAYp1z80H69qRjVMfWKg5Ik0Ud8wf4,4402
-mathai/integrate.py,sha256=nUE2_ubklNIfj6QGtZTGuZmprYX-U3Ln454W-I1JddQ,17365
+mathai/fraction.py,sha256=jCIDurenm6grPWNDSY_67zci6fmsIhKG24qm2gbmYtQ,3322
+mathai/integrate.py,sha256=6Ik_uAzkLyOWCE9M7mqwH_SVTvEdiG0-UYS2KsDgjLI,17454
 mathai/inverse.py,sha256=ya7P8WjzfaAL3UXL7xqOh5GaIsXLDZ-F6lZFy3IEgaQ,2931
 mathai/limit.py,sha256=9F8i9UZh2xb-V8A5Sd1gdhDf9c2RFgpE1GdNn9MvbWI,5703
 mathai/linear.py,sha256=viGlPU8BPrjLWHlyNUvnfPHNH5d4ZBImiQMdyXaKGg0,5702
 mathai/logic.py,sha256=Ndz4Fd6aNCmzFlqoPyyIpSmV_BXmYHsurePjLyZJoNc,9809
 mathai/matrix.py,sha256=MFe6tUL4a3jYuP13fXWGwER_34AbqfoOK5kHwVHfsKk,7169
-mathai/ode.py,sha256=ABsGyA0TMfeHNG1kh_MsDcnmzkEnOHOzwNMw0QocyY0,7073
-mathai/parser.py,sha256=FcjOTM_2-YFqPNS9EyZfo76pa4CedDJCbcs8wOXc_uU,7130
+mathai/ode.py,sha256=F0Z_Zv2YsnVf4HwIJmqvIenjONaItzy5H739THkLvcU,11616
+mathai/parser.py,sha256=7NWPPzci7MZazkGG_q5uUyKCOZ_-rqvOhp9UZjzBNc4,7100
 mathai/parsetab.py,sha256=TL-4jvRM_Tx6ipwet8CFJc2DkjR4tGsbrGF_r4IC8xI,9651
-mathai/pde.py,sha256=1EuVO2y9QAQK42fMbtmxvQyAV_7wsWH9zWLvH6ZDoZQ,4710
+mathai/pde.py,sha256=KL1UFPrfyp8lI1p-mXUaEPo4Yia2GkCw9oZT2R1zhKI,3576
 mathai/printeq.py,sha256=4UgLJo-vV_YlVw_3QUQY_jQMHrFnG-ZKAyVZsd7yD6o,1450
 mathai/simplify.py,sha256=bCtYyLyc3pY04hta-MU62ii5-O4zUwGHjs1Q4WBYEvY,19680
 mathai/statistics.py,sha256=ifmaXFzRc6vIgPFWP-9EDfZZYmmMGw-WEKhoQZUaHXo,884
-mathai/structure.py,sha256=wrU7kqphSN7CqaVffyHHXD2-3t5My_Z_TtYFoUe_lTU,4099
+mathai/structure.py,sha256=u4usB0yPnem2VscgEBqKWxRN9Y4tTjymEaQh1de5Bsk,4121
 mathai/tool.py,sha256=ozcXTXLbKUnyPM9r9kz9M43YA2CBcWezcqLZfEs8rpc,6051
 mathai/trig.py,sha256=fnBbfiopcQzFg4ya1BoO5M0X_aCBnse2bjnKh1juw4I,11223
 mathai/univariate_inequality.py,sha256=LPFdWgC1y5zBwnsy1wwZxj-yP_SbqFDhCmTTzhuwoiY,16469
-mathai-0.7.7.dist-info/METADATA,sha256=mV07F05pSZIebDjsHe3QNUo3dEmFiZ6tNR2TR6Grxlk,7735
-mathai-0.7.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mathai-0.7.7.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.7.7.dist-info/RECORD,,
+mathai-0.7.9.dist-info/METADATA,sha256=KuLNc-p43qoo0WX2rG-VBhOVbknBxYm9ZZy8pI8SKr8,7735
+mathai-0.7.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mathai-0.7.9.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.7.9.dist-info/RECORD,,