mathai 2.0.2__tar.gz → 2.0.4__tar.gz

{mathai-2.0.2 → mathai-2.0.4}/PKG-INFO

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

{mathai-2.0.2 → mathai-2.0.4}/mathai/__init__.py

@@ -29,7 +29,7 @@ from .integrate import byparts as integrate_byparts
 from .integrate import sqint as integrate_fraction
 from .integrate import conv_int
 from .integrate import solve_integrate as integrate_clean
-from .integrate import integrate_formula, integrate_qm_formula, integrate_full, integrate_definite
+from .integrate import integrate_formula, integrate_trig_formula, integrate_qm_formula, integrate_full, integrate_definite
 from .integrate import normalize as integration_basic
 from .integrate import normalize_qm as integration_qm_basic
 

{mathai-2.0.2 → mathai-2.0.4}/mathai/formula_compiler.py

@@ -3,6 +3,7 @@ import itertools
 from .base import *
 from .parser import parse
 from fractions import Fraction
+from .simplify import simplify
 def simplify0_h(eq):
     if eq.name == "f_add":
         lst = [item for item in eq.children if item.name != "d_0"]
@@ -293,14 +294,14 @@ def structure(
                 for key, item3 in varlist.items():
                     local_pos = replace(local_pos, tree_form(key), item3)
                 s = print_code2(local_pos)
-                s = f"simplify0({s})==0 or (compute({s}) is not None and compute({s})>0)"
+                s = f"simplify({s})==0 or (compute({s}) is not None and compute({s})>0)"
                 d.append(TreeNode(s))
             for item2 in negative:
                 local_neg = copy.deepcopy(item2)
                 for key, item3 in varlist.items():
                     local_neg = replace(local_neg, tree_form(key), item3)
                 s = print_code2(local_neg)
-                s = f"simplify0({s})==0 or (compute({s}) is not None and compute({s})<0)"
+                s = f"simplify({s})==0 or (compute({s}) is not None and compute({s})<0)"
                 d.append(TreeNode(s))
             if len(d) == 0:
                 pass
@@ -319,10 +320,12 @@ def structure(
                 local_formula_out = replace(
                     local_formula_out, tree_form(key), item2
                 )
-            s = "\tif " + print_code(out2) + ":\n"
-            u = "\t\tif " + print_code(out) + ":\n" 
-            t = "\t\t\treturn " + print_code2(local_formula_out) + "\n"
-            final_output += s + u + t
+            out = TreeNode("f_wand", [out2, out])
+            s = "\tif " + print_code(out) + ":\n"
+            t = "\t\tout = simplify(" + print_code2(local_formula_out) + ")\n"
+            t2 = "\t\tif out is not None:\n"
+            t3 = "\t\t\treturn out\n"
+            final_output += s + t + t2 + t3
     return final_output
 def convert2(eq):
     
@@ -443,7 +446,7 @@ def formula_compiler(lst_formula):
         "contain": contain,
         "str_form": str_form,
         "copy":copy,
-        "simplify0":simplify0,
+        "simplify":simplify,
         "compute":compute,
         "remove_all":remove_all,
     }

{mathai-2.0.2 → mathai-2.0.4}/mathai/formula_data.py

@@ -14,9 +14,10 @@ formula_data = {}
 # negative constraint
 # associative arity
 formula = """
-integrate(1/(a*x+b),x) log(abs(a*x+b))/a x _ [a,b] _ [a,0] _ _ 6
-integrate((a*x+b)^c,x) (a*x+b)^(c+1)/(a*(c+1)) x _ [a,b,c] _ [[a,0],[c,-1]] _ _ 1
-// dummy
+a*x^2+b*x+c true x _ [a,b,c] _ [a,0] _ _ 2
+a*x+b true x _ [a,b] _ [a,0] _ _ 4
+a false _ _ _ _ _ _ _ 1
+// is_integrate_subs
 
 integrate(x^2*e^(a*x+b),x) ((x^2/a)-(2*x/(a^2))+(2/(a^3)))*e^(a*x+b) x _ [a,b] _ [a,0] _ _ 6
 integrate(x*e^(a*x+b),x) ((x/a)-(1/(a^2)))*e^(a*x+b) x _ [a,b] _ [a,0] _ _ 6
@@ -37,6 +38,18 @@ integrate(a*b,x) a*integrate(b,x) x _ [a] _ [a,1] _ _ 6
 integrate(a+b,x) integrate(a,x)+integrate(b,x) x _ _ _ [[a,0],[b,0]] _ _ 6
 // integration
 
+integrate(cos(a*x+b)/sin(a*x+b),x) log(abs(sin(a*x+b)))/a x _ [a,b] _ [a,0] _ _ 2
+integrate(sin(a*x+b)/cos(a*x+b),x) -log(abs(cos(a*x+b)))/a x _ [a,b] _ [a,0] _ _ 2
+integrate(sin(x)^a*cos(x)^b,x) -sin(x)^(a+1)*cos(x)^(b+1)/(b+1)+(a+b+2)/(b+1)*integrate(sin(x)^a*cos(x)^(b+2),x) x _ [a,b] _ [b,-1] a b 4
+integrate((sin(x)/cos(x))^a,x) tan(x)^(a-1)/(a-1)-integrate((sin(x)/cos(x))^(a-2),x) x _ a _ [[a,1],[a,0]] a _ 4
+integrate((cos(x)/sin(x))^a,x) -cot(x)^(a-1)/(a-1)-integrate((cos(x)/sin(x))^(a-2),x) x _ a _ [[a,1],[a,0]] a _ 4
+integrate(sin(x)^a/cos(x),x) -sin(x)^(a-1)/(a-1)+integrate(sin(x)^(a-2)/cos(x),x) x _ a _ [[a,1],[a,0]] a _ 4
+integrate(cos(x)^a/sin(x),x) cos(x)^(a-1)/(a-1)+integrate(cos(x)^(a-2)/sin(x),x) x _ a _ [[a,1],[a,0]] a _ 4
+integrate(sin(x)^a*cos(x)^b,x) sin(x)^(a+1)*cos(x)^(b+1)/(a+1)-(a+b+2)/(a+1)*integrate(sin(x)^(a+2)*cos(x)^b,x) x _ [a,b] _ [a,-1] b a 4
+integrate(sin(x)^a,x) cos(x)/((a+1)*sin(x)^(a+1))+(a+2)/(a+1)*integrate(sin(x)^(a+2),x) x _ a _ [[a,-1],[a,0]] _ a 4
+integrate(cos(x)^a,x) -sin(x)/((a+1)*cos(x)^(a+1))+(a+2)/(a+1)*integrate(cos(x)^(a+2),x) x _ a _ [[a,-1],[a,0]] _ a 4
+// integration_trig
+
 pdif(a^b,x) b*(a^(b-1))*pdif(a,x)+(a^b)*log(a)*pdif(b,x) x _ k _ _ _ _ 6
 pdif(sin(a),x) cos(a)*pdif(a,x) x _ k _ [[c,1],[d,1],[f,0],[g,0]] _ _ 2
 pdif(cos(a),x) -sin(a)*pdif(a,x) x _ k _ [[c,1],[d,1],[f,0],[g,0]] _ _ 2
@@ -114,7 +127,7 @@ a*x^2+b*x+c a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) _ x
 """
 
 def load_formula(label):
-    global formula_data
+    global formula_data 
     return formula_data[label]
 def convert_lst(eq):
     if eq.name == "f_list":
@@ -144,7 +157,7 @@ def init_formula(label_list="all"):
     for item in formula.strip().split("\n\n"):
         item = item.split("\n")
         item[-1] = item[-1][3:]
-        if label_list == "all" or item[-1] in label_list:
+        if label_list == "all" or item[-1] in label_list or (label_list == "god" and item[-1] in "is_integrate_subs integration_trig differentiation integration quadratic trigonometry_misc".split(" ")):
             formula_data[item[-1]] = compile_formula("\n".join(item[:-1]))
             print(f"{item[-1]} formula set compiled")
     print()

{mathai-2.0.2 → mathai-2.0.4}/mathai/integrate.py

@@ -16,7 +16,13 @@ from .trig import trig0, trig2, trig3, trig4, trig1, trig5, trig6
 from .apart import apart, apart2
 from .univariate_inequality import wavycurvy, eq2range, range2eq2, Range
 from .printeq import *
-
+def all_branch(eq):
+    if eq.children == []:
+        return []
+    out = [eq.name]
+    for child in eq.children:
+        out += all_branch(child)
+    return list(set(out))
 def subs_heuristic(eq, var):
     output = []
     last = []
@@ -27,6 +33,8 @@ def subs_heuristic(eq, var):
         if eq.name in ["f_pow"] and var.name in str_form(eq):
             if eq.children[1].name[:2] != "v_":
                 output.append(str_form(eq))
+        if eq.name in ["f_arctan"] and var.name in str_form(eq.children[0]):
+            output.append(str_form(eq))
         if eq.name in ["f_pow", "f_sin", "f_cos", "f_arcsin"] and var.name in str_form(eq.children[0]):
             if eq.children[0].name[:2] != "v_":
                 output.append(str_form(eq.children[0]))
@@ -52,21 +60,19 @@ def subs_heuristic(eq, var):
     tmp = list(set([simplify(tree_form(x)) for x in output]))
     tmp = sorted(tmp, key=lambda x: len(str_form(x)))
     poly_term = None
-    term_degree = 20
+    fx = load_formula("is_integrate_subs")
     output = []
-    for item in tmp:
-        n = poly(simplify(item), var.name)
-        if n is None:
-            output.append(item)
-        else:
-            if term_degree > len(n):
+    if set(all_branch(eq)) <= set("f_add f_mul f_pow".split(" ")):
+        for item in tmp:
+            if fx(item).name == "s_true":
                 poly_term = item
-                term_degree = len(n)
+            else:
+                output.append(item)
     p = None
     if poly_term is None:
         p = tmp
     else:
-        p = [poly_term]+output
+        p = output+[poly_term]
     last = list(set(last))
     if len(p)>3:
         p = p[:3]
@@ -164,17 +170,22 @@ def integrate_subs(equation, term, v1, v2, extra):
     eq = equation
     termeq = term
     t = inverse(copy.deepcopy(termeq), v1)
-    g = inverse(termeq, v2)
+    g = inverse(copy.deepcopy(termeq), v2)
     if g is None:
         return none
     if t is None:
         return none
     else:
         t = expand(t)
-        eq = replace(eq, tree_form(v1), t)
-        eq2 = replace(diff(g, v1), tree_form(v1), t)
-        equation = eq/eq2
-        equation = simplify(equation)
+        eq3 = diff(g, v1)
+        eq2 = replace(eq, g, tree_form(v2))
+        eq4 = simplify(eq2/eq3)
+        if not contain(eq4, tree_form(v1)):
+            equation = eq4
+        else:
+            eq = replace(eq, tree_form(v1), t)
+            equation = eq/eq3
+            equation = simplify(equation)
     if v1 in str_form(equation):
         return none
     return dowhile(TreeNode("f_subs", [TreeNode("f_integrate", [simplify(equation), tree_form(origv2)]),tree_form(origv2) ,g]+extra), lambda x: simplify(trig4(trig0(x))))
@@ -336,6 +347,7 @@ def byparts(eq):
     return TreeNode(eq.name, [byparts(child) for child in eq.children])
 
 integrate_formula = lambda x: load_formula("integration")(x)
+integrate_trig_formula = lambda x: load_formula("integration_trig")(x)
 
 def shorten(eq):
     if eq.name.startswith("d_"):
@@ -532,8 +544,8 @@ def integrate_full(root):
     orig = copy.deepcopy(root)
     eq = root
     for item in [[lambda x: x, simplify, expand, normalize], [factor2, apart, normalize2, normalize], [trig1, normalize2],\
-                 [factor1, normalize, trig6, normalize, expand, normalize, integrate_subs_main, normalize, factor2, simplify, apart, normalize2],\
-                 [normalize, integrate_subs_main, normalize2, expand, normalize, byparts, normalize]]:
+                 [factor1, normalize, trig6, normalize, expand, normalize, integrate_subs_main, normalize, factor2, simplify, integrate_trig_formula, trig1, apart, normalize2],\
+                 [normalize, integrate_subs_main, normalize2, expand, normalize, byparts, normalize], [integrate_trig_formula, trig1, integrate_formula]]:
         for item2 in item:
             eq = item2(eq)
             if eq not in log:

{mathai-2.0.2 → mathai-2.0.4}/mathai.egg-info/PKG-INFO

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

{mathai-2.0.2 → mathai-2.0.4}/setup.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 setup(
     name="mathai",
-    version="2.0.2",
+    version="2.0.4",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",