mathai 0.7.8__py3-none-any.whl → 0.8.0__py3-none-any.whl

mathai/ode.py

@@ -1,6 +1,7 @@
+import itertools
 from collections import Counter
-from .diff import diff
-from .factor import factor, factor2
+from .diff import diff, diff2
+from .factor import factor, factor2, term_common2
 from .expand import expand
 from .base import *
 from .fraction import fraction
@@ -9,71 +10,110 @@ 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
+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
-    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]
+    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
                 
-                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):
-    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]]
+    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 = out[0]
+        out[0] = fraction(1/out[0])
+        out[1] = fraction(1/out[1])
     return simplify(e0(out[0]-out[1]))
 
 def allocvar():
@@ -88,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):
@@ -136,11 +166,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()
+    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}"))
@@ -149,28 +185,38 @@ def diffsolve(eq):
         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 = replace(eq2, (a*b).fx("dif"), a.fx("dif")*b + b.fx("dif")*a)
-            eq2 = expand(simplify(fraction(simplify(eq2))))
+            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):
@@ -219,6 +265,19 @@ def order(eq,m=0):
             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]
@@ -260,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

@@ -87,7 +87,6 @@ def parse(equation, funclist=None):
     parser_main = Lark(grammar2, start='start', parser='lalr')
     parse_tree = parser_main.parse(equation)
     
-    # Convert Lark tree to TreeNode
     def convert_to_treenode(parse_tree):
         if isinstance(parse_tree, Tree):
             node = TreeNode(parse_tree.data)
@@ -96,7 +95,6 @@ def parse(equation, funclist=None):
         else:
             return TreeNode(str(parse_tree))
 
-    # Flatten unnecessary nodes like pass_through
     def remove_past(equation):
         if equation.name in {"number", "paren", "func", "variable", "pass_through", "cnumber", "string", "matrix"}:
             if len(equation.children) == 1:
@@ -107,7 +105,6 @@ def parse(equation, funclist=None):
         equation.children = [remove_past(child) for child in equation.children]
         return equation
 
-    # Handle indices if any
     def prefixindex(equation):
         if equation.name == "base" and len(equation.children) > 1:
             return TreeNode("index", [equation.children[0]] + equation.children[1].children)
@@ -117,16 +114,15 @@ def parse(equation, funclist=None):
     tree_node = remove_past(tree_node)
     tree_node = prefixindex(tree_node)
 
-    # Convert function names and constants
     def fxchange(tree_node):
         tmp3 = funclist if funclist is not None else []
         if tree_node.name == "neg":
             child = fxchange(tree_node.children[0])
-            # if the child is a number, make it negative
+            
             if child.name.startswith("d_") and re.match(r"d_\d+(\.\d+)?$", child.name):
                 return TreeNode("d_" + str(-int(child.name[2:])))
             else:
-                # otherwise subtract from zero
+
                 return TreeNode("f_sub", [tree_form("d_0"), child])
         if tree_node.name == "pass_through":
             return fxchange(tree_node.children[0])
@@ -137,11 +133,9 @@ def parse(equation, funclist=None):
 
     tree_node = fxchange(tree_node)
 
-    # Replace common constants
     for const in ["e","pi","kc","em","ec","anot","hbar","false","true","i","nabla"]:
         tree_node = replace(tree_node, tree_form("d_"+const), tree_form("s_"+const))
 
-    # Map letters to variables
     for i, c in enumerate(["x","y","z"] + [chr(x+ord("a")) for x in range(0,23)]):
         tree_node = replace(tree_node, tree_form("d_"+c), tree_form("v_"+str(i)))
     for i, c in enumerate([chr(x+ord("A")) for x in range(0,26)]):

mathai/pde.py

@@ -1,5 +1,5 @@
 from .expand import expand
-from .ode import diffsolve, inversediff, order, groupe, epowersplit
+from .ode import diffsolve, inversediff, order, groupe, epowersplit, subs2
 from .base import *
 from .simplify import simplify
 from .diff import diff2
@@ -16,13 +16,7 @@ def capital2(eq):
         if out is not None:
             return out
     return None
-def subs2(eq, orde):
-    if eq.name == "f_pdif":
-        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
@@ -36,6 +30,8 @@ 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]
@@ -95,8 +91,7 @@ def pde_sep(eq):
             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] = 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)