mathai 0.7.7__tar.gz → 0.7.8__tar.gz

{mathai-0.7.7 → mathai-0.7.8}/PKG-INFO

@@ -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 → mathai-0.7.8}/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-0.7.7 → mathai-0.7.8}/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-0.7.8/mathai/diff.py

@@ -0,0 +1,156 @@
+from .trig import trig0
+from .simplify import simplify
+from .base import *
+
+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)
+        if "v_" not in str_form(eq):
+            return tree_form("d_0")
+        if eq.name == "f_add":
+            add = tree_form("d_0")
+            for child in eq.children:
+                add += diffeq(child)
+            return add
+        elif eq.name == "f_abs":
+            return diffeq(eq.children[0])*eq.children[0]/eq
+        elif eq.name == "f_pow" and eq.children[0].name == "s_e":
+            return diffeq(eq.children[1])*eq
+        elif eq.name == "f_tan":
+            return diffeq(eq.children[0])/(eq.children[0].fx("cos")*eq.children[0].fx("cos"))
+        elif eq.name == "f_log":
+            return diffeq(eq.children[0])*(tree_form("d_1")/eq.children[0])
+        elif eq.name == "f_arcsin":
+            return diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
+        elif eq.name == "f_arccos":
+            return tree_form("d_-1")*diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
+        elif eq.name == "f_arctan":
+            return diffeq(eq.children[0])/(tree_form("d_1")+eq.children[0]*eq.children[0])
+        elif eq.name == "f_pow" and "v_" in str_form(eq.children[1]):
+            a, b = eq.children
+            return a**b * ((b/a) * diffeq(a) + a.fx("log") * diffeq(b))
+        elif eq.name == "f_mul":
+            add = tree_form("d_0")
+            for i in range(len(eq.children)):
+                tmp = eq.children.pop(i)
+                if len(eq.children)==1:
+                    eq2 = eq.children[0]
+                else:
+                    eq2 = eq
+                add += diffeq(tmp)*eq2
+                eq.children.insert(i, tmp)
+            return add
+        elif eq.name == "f_sin":
+            eq.name = "f_cos"
+            return diffeq(eq.children[0])*eq
+        elif eq.name == "f_cos":
+            eq.name = "f_sin"
+            return tree_form("d_-1")*diffeq(eq.children[0])*eq
+        elif eq.name[:2] == "v_":
+            return TreeNode("f_dif", [eq])
+        elif eq.name == "f_pow" and "v_" not in str_form(eq.children[1]):
+            base, power = eq.children
+            dbase = diffeq(base)
+            b1 = power - tree_form("d_1")
+            bab1 = TreeNode("f_pow", [base, b1])
+            return power * bab1 * dbase
+        return TreeNode("f_dif", [eq, tree_form(var)])
+    def helper2(equation, var="v_0"):
+        if equation.name == "f_dif":
+            if equation.children[0].name == var:
+                return tree_form("d_1")
+            if var not in str_form(equation.children[0]):
+                return tree_form("d_0")
+            else:
+                return equation
+        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]))
+        return TreeNode(eq.name, [calc(child) for child in eq.children])
+    if var is None:
+        return simplify(calc(equation))
+    equation = diffeq(trig0(equation))
+    equation = helper2(equation, var)
+    return simplify(equation)
+

{mathai-0.7.7 → mathai-0.7.8}/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-0.7.8/mathai/ode.py

@@ -0,0 +1,266 @@
+from collections import Counter
+from .diff import diff
+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):
+    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")
+
+def epowersplit(eq):
+    if eq.name == "f_pow" and eq.children[1].name == "f_add":
+        return product([eq.children[0]**child for child in eq.children[1].children])
+    return TreeNode(eq.name, [epowersplit(child) for child in eq.children])
+def esolve(s):
+    if s.name == "f_add" and "f_log" in str_form(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:
+        return None
+    s = summation(s)
+    s = simplify(e0(s))
+    
+    return groupe(s)
+def e0(eq):
+    return TreeNode("f_eq", [eq, tree_form("d_0")])
+def e1(eq):
+    if eq.name == "f_eq":
+        eq = eq.children[0]
+    return eq
+def groupe(eq):
+    eq = esolve(eq)
+    eq = simplify(eq)
+    eq = fraction(eq)
+    eq = simplify(eq)
+    eq = epowersplit(eq)
+    return 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:
+        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 = 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
+def clist(x):
+    return list(x.elements())
+def collect_term(eq, term_lst):
+    
+    lst = None
+    if eq.name == "f_add":
+        lst = copy.deepcopy(eq.children)
+    else:
+        lst = [eq]
+        
+    other = []
+    dic = {}
+    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:
+                if item in dic.keys():
+                    
+                    dic[item] += product(clist(tmp2-tmp))
+                else:
+                    
+                    dic[item] = product(clist(tmp2-tmp))
+                done = False
+                break
+        if done:
+            other.append(item2)
+    other = summation(other)
+    
+    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"):
+        tmp = out[0][b.fx("dif")]
+        if tmp != tree_form("d_0"):
+            
+            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")]
+            
+            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-0.7.7 → mathai-0.7.8}/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-0.7.8/mathai/pde.py

@@ -0,0 +1,105 @@
+from .expand import expand
+from .ode import diffsolve, inversediff, order, groupe, epowersplit
+from .base import *
+from .simplify import simplify
+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" 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 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
+    for child in eq.children:
+        out = capital(child)
+        if out is not None:
+            return out
+    return None
+def abs_const(eq):
+    if eq.name == "f_abs":
+        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.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))
+                        if out is not None:
+                            lst[item2] = out
+                            break
+        for key in lst.keys():
+            eq2 = replace(eq2, key, lst[key])
+        if len(lst.keys()) == len(v):
+            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 = 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"))
+    
+    if out is not None:
+        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] = 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"))
+    return out

{mathai-0.7.7 → mathai-0.7.8}/mathai.egg-info/PKG-INFO

@@ -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 → mathai-0.7.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="0.7.7",
+    version="0.7.8",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

mathai-0.7.7/mathai/diff.py

@@ -1,74 +0,0 @@
-from .simplify import simplify
-from .base import *
-from .trig import trig0
-def diff(equation, var="v_0"):
-    def diffeq(eq):
-        eq = simplify(eq)
-        if "v_" not in str_form(eq):
-            return tree_form("d_0")
-        if eq.name == "f_add":
-            add = tree_form("d_0")
-            for child in eq.children:
-                add += diffeq(child)
-            return add
-        elif eq.name == "f_abs":
-            return diffeq(eq.children[0])*eq.children[0]/eq
-        elif eq.name == "f_pow" and eq.children[0].name == "s_e":
-            return diffeq(eq.children[1])*eq
-        elif eq.name == "f_tan":
-            return diffeq(eq.children[0])/(eq.children[0].fx("cos")*eq.children[0].fx("cos"))
-        elif eq.name == "f_log":
-            return diffeq(eq.children[0])*(tree_form("d_1")/eq.children[0])
-        elif eq.name == "f_arcsin":
-            return diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
-        elif eq.name == "f_arccos":
-            return tree_form("d_-1")*diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
-        elif eq.name == "f_arctan":
-            return diffeq(eq.children[0])/(tree_form("d_1")+eq.children[0]*eq.children[0])
-        elif eq.name == "f_pow" and "v_" in str_form(eq.children[1]):
-            a, b = eq.children
-            return a**b * ((b/a) * diffeq(a) + a.fx("log") * diffeq(b))
-        elif eq.name == "f_mul":
-            add = tree_form("d_0")
-            for i in range(len(eq.children)):
-                tmp = eq.children.pop(i)
-                if len(eq.children)==1:
-                    eq2 = eq.children[0]
-                else:
-                    eq2 = eq
-                add += diffeq(tmp)*eq2
-                eq.children.insert(i, tmp)
-            return add
-        elif eq.name == "f_sin":
-            eq.name = "f_cos"
-            return diffeq(eq.children[0])*eq
-        elif eq.name == "f_cos":
-            eq.name = "f_sin"
-            return tree_form("d_-1")*diffeq(eq.children[0])*eq
-        elif eq.name[:2] == "v_":
-            return TreeNode("f_dif", [eq])
-        elif eq.name == "f_pow" and "v_" not in str_form(eq.children[1]):
-            base, power = eq.children
-            dbase = diffeq(base)
-            b1 = power - tree_form("d_1")
-            bab1 = TreeNode("f_pow", [base, b1])
-            return power * bab1 * dbase
-        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")
-            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])
-    def calc(eq):
-        if eq.name == "f_dif":
-            return diffeq(trig0(eq.children[0]))
-        return TreeNode(eq.name, [calc(child) for child in eq.children])
-    if var is None:
-        return simplify(calc(equation))
-    equation = diffeq(trig0(equation))
-    equation = helper(equation, var)
-    return simplify(equation)

mathai-0.7.7/mathai/ode.py

@@ -1,189 +0,0 @@
-from collections import Counter
-from .diff import diff
-from .factor import factor
-from .expand import expand
-from .base import *
-from .fraction import fraction
-from .simplify import simplify
-import copy
-
-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))
-
-def allocvar():
-    return tree_form("v_101")
-
-def epowersplit(eq):
-    if eq.name == "f_pow" and eq.children[1].name == "f_add":
-        return product([eq.children[0]**child for child in eq.children[1].children])
-    return TreeNode(eq.name, [epowersplit(child) for child in eq.children])
-def esolve(s):
-    if s.name == "f_add" and "f_log" in str_form(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:
-        return None
-    s = summation(s)
-    s = simplify(e0(s))
-    
-    return groupe(s)
-def e0(eq):
-    return TreeNode("f_eq", [eq, tree_form("d_0")])
-def e1(eq):
-    if eq.name == "f_eq":
-        eq = eq.children[0]
-    return eq
-def groupe(eq):
-    eq = esolve(eq)
-    eq = simplify(eq)
-    eq = fraction(eq)
-    eq = simplify(eq)
-    eq = epowersplit(eq)
-    return 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 = 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 = 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
-def clist(x):
-    return list(x.elements())
-def collect_term(eq, term_lst):
-    
-    lst = None
-    if eq.name == "f_add":
-        lst = eq.children
-    else:
-        lst = [eq]
-        
-    other = []
-    dic = {}
-    term_lst = sorted(term_lst, key=lambda x: -len(factor_generation(x)))
-    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 item in dic.keys():
-                    dic[item] += product(clist(tmp2-tmp))
-                else:
-                    dic[item] = product(clist(tmp2-tmp))
-                done = False
-                break
-        if done:
-            other.append(item2)
-    other = summation(other)
-    
-    for key in dic.keys():
-        dic[key] = simplify(dic[key])
-    return [dic, simplify(other)]
-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"):
-        tmp = out[0][b.fx("dif")]
-        if tmp != tree_form("d_0"):
-            
-            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")]
-            
-            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-0.7.7/mathai/pde.py

@@ -1,139 +0,0 @@
-from .ode import diffsolve
-from .base import *
-from .simplify import simplify
-from .diff import diff
-from .fraction import fraction
-from .parser import parse
-from .inverse import inverse
-def capital2(eq):
-    if eq.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
-    for child in eq.children:
-        out = capital(child)
-        if out is not None:
-            return out
-    return None
-def abs_const(eq):
-    if eq.name == "f_abs":
-        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.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)
-                for item2 in v:
-                    if contain(item, item2):
-                        out = inverse(item.children[0], str_form(item2))
-                        if out is not None:
-                            lst[item2] = out
-                            break
-        for key in lst.keys():
-            eq2 = replace(eq2, key, lst[key])
-        if len(lst.keys()) == len(v):
-            return simplify(eq2)
-    return TreeNode(eq.name, [want(child) for child in eq.children])
-def pde_sep(eq):
-    if eq.name == "f_eq":
-        eq = eq.children[0]
-    r2 = capital2(eq)
-    
-    eq =  simplify(fraction(subs(eq, r2)))
-    out = inverse_pde(eq,tree_form("d_0"))
-    if out is not None:
-        out = list(out)
-        lst = []
-        for i in range(2):
-            out[i] = subs2(out[i])
-            out[i] = TreeNode("f_eq", [out[i], tree_form("v_102")])
-            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] = 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"))
-    return out