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

mathai/__init__.py

@@ -1,6 +1,8 @@
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 
+from .pde import pde_sep, want
+
 from .linear import linear_solve, linear_or
 
 from .expand import expand
@@ -11,14 +13,12 @@ from .printeq import printeq, printeq_str
 
 from .simplify import simplify
 
-from .integrate import ref as integrate_save
 from .integrate import integrate_subs_main as integrate_subs
 from .integrate import byparts as integrate_byparts
 from .integrate import sqint as integrate_fraction
 from .integrate import integrate_summation
 from .integrate import rm_const as integrate_const
 from .integrate import solve_integrate as integrate_clean
-from .integrate import inteq as integrate_recursive
 from .integrate import integrate_formula
 
 from .diff import diff

mathai/base.py

@@ -403,7 +403,7 @@ def string_equation_helper(equation_tree):
     if equation_tree.name == "f_index":
         return string_equation_helper(equation_tree.children[0])+"["+",".join([string_equation_helper(child) for child in equation_tree.children[1:]])+"]"
     s = "(" 
-    if len(equation_tree.children) == 1 or equation_tree.name[2:] in [chr(ord("A")+i) for i in range(26)]+["limitpinf", "subs", "try", "ref","limit", "integrate", "exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
+    if len(equation_tree.children) == 1 or equation_tree.name[2:] in [chr(ord("A")+i) for i in range(26)]+["want", "limitpinf", "subs", "try", "ref","limit", "integrate", "exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
         s = equation_tree.name[2:] + s
     sign = {"f_not":"~", "f_wadd":"+", "f_wmul":"@", "f_intersection":"&", "f_union":"|", "f_sum2":",", "f_exist":",", "f_forall":",", "f_sum":",","f_covariance": ",", "f_B":",", "f_imply":"->", "f_ge":">=", "f_le":"<=", "f_gt":">", "f_lt":"<", "f_cosec":"?" , "f_equiv": "<->", "f_sec":"?", "f_cot": "?", "f_dot": ".", "f_circumcenter":"?", "f_transpose":"?", "f_exp":"?", "f_abs":"?", "f_log":"?", "f_and":"&", "f_or":"|", "f_sub":"-", "f_neg":"?", "f_inv":"?", "f_add": "+", "f_mul": "*", "f_pow": "^", "f_poly": ",", "f_div": "/", "f_sub": "-", "f_dif": ",", "f_sin": "?", "f_cos": "?", "f_tan": "?", "f_eq": "=", "f_sqrt": "?"}
     arr = []

mathai/integrate.py

@@ -376,6 +376,7 @@ def integration_formula_init():
         (f"1/cos(A*{var}+B)^2", f"tan(A*{var}+B)/A"),
         (f"1/sin(A*{var}+B)", f"log(abs(tan((A*{var}+B)/2)))/A"),
         (f"1/cos(A*{var}+B)^3", f"(sec(A*{var}+B)*tan(A*{var}+B)+log(abs(sec(A*{var}+B)+tan(A*{var}+B))))/(2*A)")
+        #(f"cos({var})*e^(A*{var})", f"e^(A*{var})/(A^2+1)*(A*cos({var})+sin({var}))")
     ]
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A"), parse("1")], [parse("B"), parse("0")]]
@@ -449,13 +450,18 @@ def integrate_formula(equation):
         if out is not None:
             
             return out
-        expr_str = str_form(shorten(integrand))
-        if len(expr_str) < 30:
+
+        short = shorten(integrand)
+        expr_str = str_form(short)
+        
+        if len(str(short)) < 25:
+            
             if expr_str.count("f_sin") + expr_str.count("f_cos") > 2:
                 out = transform_formula(integrand, wrt.name, formula_gen4[0], formula_gen4[1], formula_gen4[2])
                 if out is not None:
                     return out
             if "f_cos" in expr_str and contain(integrand, tree_form("s_e")):
+                
                 out = transform_formula(integrand, wrt.name, formula_gen11[0], formula_gen11[1], formula_gen11[2])
                 if out is not None:
                     return out

mathai/ode.py

@@ -1,3 +1,4 @@
+from collections import Counter
 from .diff import diff
 from .factor import factor
 from .expand import expand
@@ -7,7 +8,7 @@ from .simplify import simplify
 import copy
 
 def inversediff(lhs, rhs):
-    count = 4
+    count = 5
     while contain(rhs, tree_form("v_1")) or contain(lhs, tree_form("v_0")):
         success = False
         if rhs.name == "f_add":
@@ -49,10 +50,8 @@ def inversediff(lhs, rhs):
             return simplify(e0(lhs-rhs))
     return simplify(e0(lhs-rhs))
 
-intconst = ["v_"+str(i) for i in range(101,150)]
 def allocvar():
-    global intconst
-    return tree_form(intconst.pop(0))
+    return tree_form("v_101")
 
 def epowersplit(eq):
     if eq.name == "f_pow" and eq.children[1].name == "f_add":
@@ -131,5 +130,60 @@ def diffsolve(eq):
             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"))
-        return orig
+        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/pde.py

@@ -0,0 +1,139 @@
+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

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

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

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

@@ -1,21 +1,22 @@
-mathai/__init__.py,sha256=elVGU1vjxbvzY3CQ8M5kzj5i6o8YyCsdb2vw-kSxTN0,1575
+mathai/__init__.py,sha256=XkmMsqLr7MkYu1lMwwgsiEagtuOK_KsxLTbAHXgYSmo,1510
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=XNmXWADG7mA4AeyFbCUsjBvUzDnw8AzWscX0Cc3GjvA,14854
+mathai/base.py,sha256=LdIpxwqhqjL-O7GTfzyzCNN5_Zibp6dNZQVD42SwfIw,14862
 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/expand.py,sha256=IuzMX6emCT480VE27aCtR0eWU-rJ2VElvRLVa2xcRw0,2582
 mathai/factor.py,sha256=mz_UlPuAqwvsextLB0FM5KWIuuDiMMKG51bXrofqzw8,12830
 mathai/fraction.py,sha256=3Qer3K20ZO2exMAYp1z80H69qRjVMfWKg5Ik0Ud8wf4,4402
-mathai/integrate.py,sha256=C_lqYgQN4UiriCb_LDkpwtKx7XJhp_K8T9skCkxWqas,17208
+mathai/integrate.py,sha256=nUE2_ubklNIfj6QGtZTGuZmprYX-U3Ln454W-I1JddQ,17365
 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=csfXXodMmfujl5klMQFXFqQsm31mfqJC0R3A-Fh2XA0,5297
+mathai/ode.py,sha256=ABsGyA0TMfeHNG1kh_MsDcnmzkEnOHOzwNMw0QocyY0,7073
 mathai/parser.py,sha256=FcjOTM_2-YFqPNS9EyZfo76pa4CedDJCbcs8wOXc_uU,7130
 mathai/parsetab.py,sha256=TL-4jvRM_Tx6ipwet8CFJc2DkjR4tGsbrGF_r4IC8xI,9651
+mathai/pde.py,sha256=1EuVO2y9QAQK42fMbtmxvQyAV_7wsWH9zWLvH6ZDoZQ,4710
 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
@@ -23,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.5.dist-info/METADATA,sha256=GSXYZlfllT4oNidG0NEqx549V4kq5GMgyCwNSAh1K-k,7735
-mathai-0.7.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mathai-0.7.5.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.7.5.dist-info/RECORD,,
+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,,