mathai 0.7.7__py3-none-any.whl → 0.7.8__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/integrate.py

@@ -159,7 +159,7 @@ def rm(eq):
 def solve_integrate(eq):
     
     eq2 = dowhile(eq, _solve_integrate)
-    eq2 = dowhile(eq2, handle_try)
+    #eq2 = dowhile(eq2, handle_try)
     eq2 = rm(eq2)
     if eq2.name == "f_try":
         eq2.children = list(set(eq2.children))

mathai/ode.py

@@ -1,54 +1,80 @@
 from collections import Counter
 from .diff import diff
-from .factor import factor
+from .factor import factor, factor2
 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 jjj(lhs, rhs):
+    lst = [lhs, rhs]
+    for i in range(2):
+        if lst[i].name in ["f_mul", "f_add"]:
+            
+            out = []
+            for child in lst[i].children:
+                
+                if not contain(child, tree_form(f"v_{i}")):
+                    out.append(child)
+            if out == []:
+                continue
+            out = TreeNode(lst[i].name, out)
+            
+            if len(out.children) == 1:
+                out = out.children[0]
+            out = out.copy_tree()
+            if lst[i].name == "f_add":
+                lst[i] = lst[i] - out
+                lst[1-i] = lst[1-i] - out
+            else:
+                lst[i] = lst[i] / out
+                lst[1-i] = lst[1-i] / out
+                
+            lst = [simplify(expand(simplify(item))) for item in lst]
+    return lst
+
+def kkk(lhs, rhs, depth=3):
+    
+    lst = jjj(lhs, rhs)
+    
+    if depth < 0:
+        return lst, False
+    if not contain(lst[0], tree_form("v_1")) and not contain(lst[1], tree_form("v_0")):
+        return lst, True
+    orig = copy.deepcopy(lst)
+    for i in range(2):
+        if lst[i].name in ["f_mul", "f_add"]:
+            for child in lst[i].children:
+                
+                out = child
+                if lst[i].name == "f_add":
+                    lst[i] = lst[i] - out
+                    lst[1-i] = lst[1-i] - out
+                else:
+                    lst[i] = lst[i] / out
+                    lst[1-i] = lst[1-i] / out
+                lst = [simplify(item) for item in lst]
+                
+                output = kkk(lst[0], lst[1], depth-1)
+                lst = orig
+                if output[1]:
+                    return output
+    return lst, False
 
 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))
+    out = [[tree_form("d_0"), lhs-rhs], False]
+    while True:
+        out = list(kkk(out[0][0], out[0][1]))
+        if out[1]:
+            break
+        out[0] = [simplify(item) for item in out[0]]
+        
+    out = out[0]
+    return simplify(e0(out[0]-out[1]))
 
 def allocvar():
     return tree_form("v_101")
@@ -110,13 +136,17 @@ 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()
-
+    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:
@@ -125,7 +155,8 @@ def diffsolve(eq):
             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 = replace(eq2, (a*b).fx("dif"), a.fx("dif")*b + b.fx("dif")*a)
+            eq2 = expand(simplify(fraction(simplify(eq2))))
             eq2 = diffsolve_sep(eq2)
             eq2 = diffsolve_sep2(eq2)
             if eq2 is not None:
@@ -135,6 +166,7 @@ def diffsolve(eq):
     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
@@ -145,23 +177,28 @@ 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 +209,48 @@ 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 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"):

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,28 @@
-from .ode import diffsolve
+from .expand import expand
+from .ode import diffsolve, inversediff, order, groupe, epowersplit
 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")
+def subs2(eq, orde):
     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])
+        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 capital(eq):
     if eq.name[:2] == "f_" and eq.name != eq.name.lower():
         return eq
@@ -98,12 +37,14 @@ def abs_const(eq):
     return TreeNode(eq.name, [abs_const(child) for child in eq.children])
 def want(eq):
     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 +54,51 @@ 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] = subs2(out[i], order(out[i]))
+            
             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-0.7.7.dist-info → mathai-0.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.7.7
+Version: 0.7.8
 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.8.dist-info}/RECORD

@@ -1,22 +1,22 @@
-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/integrate.py,sha256=dA5AilUSOf4axVzi6KAF3OIaxmTetFjKt-5OpEaiYuo,17366
 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=x6pAzml9pWZ-sr2k6JRfHTX1OJT82Tx7Yf-kTfAOe7E,9104
+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=JpPU73tGu1UH4ysLFeM1GaX-3ZdjykLu7CUdi1tfUTo,3814
 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
@@ -24,7 +24,7 @@ mathai/structure.py,sha256=wrU7kqphSN7CqaVffyHHXD2-3t5My_Z_TtYFoUe_lTU,4099
 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.8.dist-info/METADATA,sha256=13qi9377FQiULbVaonDa0-auk8pBon8jah_xZykHCP4,7735
+mathai-0.7.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mathai-0.7.8.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.7.8.dist-info/RECORD,,