mathai 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

mathai/__init__.py

@@ -11,14 +11,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/diff.py

@@ -63,6 +63,12 @@ def diff(equation, var="v_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/expand.py

@@ -70,6 +70,9 @@ def expand_nc(expr, label="f_mul"):
         return TreeNode(label, factors)
 
 
-def expand(eq, over="*"):
+def expand2(eq, over="*"):
     over = {"@": "f_wmul", ".":"f_dot", "*":"f_mul"}[over]
     return expand_nc(eq, over)
+def expand(eq, over="*"):
+    eq = expand2(eq, over)
+    return TreeNode(eq.name, [expand(child, over) for child in eq.children])

mathai/factor.py

@@ -134,6 +134,11 @@ def merge_sqrt(eq):
                 n = int(eq.children[0].name[2:])
                 a, b =sqrt_to_a_sqrt_b(n)
                 return tree_form("d_"+str(b))**(tree_form("d_2")**-1)*tree_form("d_"+str(a))
+        if eq.name == "f_pow" and frac(eq.children[1]) == Fraction(-1,2):
+            if frac(eq.children[0]) is not None:
+                out = frac(eq.children[0])
+                b, a = [tree_form("d_"+str(x)) for x in [out.numerator, out.denominator]]
+                return a**(tree_form("d_2")**-1)/b**(tree_form("d_2")**-1)
         return TreeNode(eq.name, [helper(child) for child in eq.children])
     return helper(_merge_sqrt(eq))
 def rationalize_sqrt(eq):

mathai/fraction.py

@@ -92,7 +92,7 @@ def fraction(eq):
                     c = TreeNode("f_mul", c_children)
                 c = TreeNode("f_pow", [c, tree_form("d_-1")])
 
-                result_map[node] = TreeNode("f_mul", [simplify(expand(a)), c])
+                result_map[node] = TreeNode("f_mul", [simplify(expand(simplify(a))), c])
                 continue
 
         # Default: just reconstruct node

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,5 @@
+from collections import Counter
+from .diff import diff
 from .factor import factor
 from .expand import expand
 from .base import *
@@ -118,7 +120,72 @@ def diffsolve(eq):
     orig = eq.copy_tree()
 
     
-    eq = diffsolve_sep2(eq)
+    eq = diffsolve_sep2(diffsolve_sep(eq))
     if eq is None:
-        return orig
+        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.4.dist-info → mathai-0.7.6.dist-info}/METADATA

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

{mathai-0.7.4.dist-info → mathai-0.7.6.dist-info}/RECORD

@@ -1,19 +1,19 @@
-mathai/__init__.py,sha256=elVGU1vjxbvzY3CQ8M5kzj5i6o8YyCsdb2vw-kSxTN0,1575
+mathai/__init__.py,sha256=uSG7914Pp9wW9801C38J76gWD3MIoJa5hbJyVEpXfgg,1476
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
 mathai/base.py,sha256=XNmXWADG7mA4AeyFbCUsjBvUzDnw8AzWscX0Cc3GjvA,14854
 mathai/bivariate_inequality.py,sha256=Da-A1kqVynR0tNOlEI7GSTf5T2vNkcF4etL9-EoyPJg,11415
 mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
-mathai/diff.py,sha256=RSTwlfeddvYXUDShCeRdcPjsmAS8Vf5OkYJAaUBPaiM,3060
-mathai/expand.py,sha256=-nMd-TM4m5eIu61yW7YeaH_QCIPUdOqmtUfa9E7Fy94,2448
-mathai/factor.py,sha256=3wcmZOGUqMlLj4v2DA14ZLqEQ7khavOi7PjZJU6VX40,12494
-mathai/fraction.py,sha256=88xvRpDGfFi8tbe1QIyejdSP91HcErrN4VS2MxzbhrY,4392
-mathai/integrate.py,sha256=C_lqYgQN4UiriCb_LDkpwtKx7XJhp_K8T9skCkxWqas,17208
+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=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=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
+mathai/ode.py,sha256=vQmCedrfC8-Z0nTSogDYyFu7ASk9pu0E2iYLsfw0zvw,7152
 mathai/parser.py,sha256=FcjOTM_2-YFqPNS9EyZfo76pa4CedDJCbcs8wOXc_uU,7130
 mathai/parsetab.py,sha256=TL-4jvRM_Tx6ipwet8CFJc2DkjR4tGsbrGF_r4IC8xI,9651
 mathai/printeq.py,sha256=4UgLJo-vV_YlVw_3QUQY_jQMHrFnG-ZKAyVZsd7yD6o,1450
@@ -23,7 +23,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.4.dist-info/METADATA,sha256=KrAeV2SCsA8woWqHAHlIHTrkXpGNXiAYG3Q9qMQ6q_Y,7735
-mathai-0.7.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mathai-0.7.4.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.7.4.dist-info/RECORD,,
+mathai-0.7.6.dist-info/METADATA,sha256=CtT2xE0HxPzOuwYgjgbr-jU-idsfJC8Zh8azf53h3eA,7735
+mathai-0.7.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mathai-0.7.6.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.7.6.dist-info/RECORD,,