mathai 2.3.7__tar.gz → 2.3.9__tar.gz

{mathai-2.3.7 → mathai-2.3.9}/PKG-INFO

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

{mathai-2.3.7 → mathai-2.3.9}/mathai/__init__.py

@@ -7,6 +7,8 @@ from .qm import hydrogen_gse, helium_gse, power_rule
 
 from .graphics import draw_graphics_from_solution, solve_graphics, solve_graphics_string
 
+from .benchmark import benchmark_ncert
+
 from .lambda_calculus import lambda_expand, lambda_compress, lambda_reduce
 
 from .electronic import Edge, CircuitGraph, find_resistance

{mathai-2.3.7 → mathai-2.3.9}/mathai/apart.py

@@ -51,7 +51,10 @@ def _apart(eq, v=None):
             if n > 3:
                 return eq
             n = tree_form("d_"+str(n))
-            l = len(poly(item, v))
+            l = poly(item, v)
+            if l is None:
+                return eq
+            l = len(l)
             if l == 3:
                 a = alloclst.pop(0)
                 b = alloclst.pop(0)

mathai-2.3.9/mathai/benchmark.py

@@ -0,0 +1,18 @@
+import random
+from .decision import god
+def benchmark_ncert(max_count=5):
+    with open("mathai/ncert_data.txt", "r", encoding="utf-8") as file:
+        content = file.read()
+        content = content.strip().split("\n")
+        random.shuffle(content)
+        output = []
+        count = 1
+        if len(max_count) > len(content):
+            max_count = len(content)
+        for item in content[:max_count]:
+            print(f"{count}/{max_count}")
+            count += 1
+            output.append((item, god(item, False)))
+        print()
+        for index, item in enumerate(output):
+            print(f"{index+1}. {item[0]} => {item[1]}")

{mathai-2.3.7 → mathai-2.3.9}/mathai/decision.py

@@ -60,9 +60,10 @@ def solve_subs(q):
     if len(solution.keys()) == 0:
         return orig
     return operation("f_and", [item for item in lst if all(not contain(item, tree_form(key)) for key in solution.keys())] + [TreeNode("f_eq", [tree_form(key), item]) for key, item in solution.items()])
-def god(string):
-    print(f"? {string}")
-    print("thinking...")
+def god(string, debug=True):
+    if debug:
+        print(f"? {string}")
+        print("thinking...")
     eq = None
     eq = parse(string)
     log = [eq]
@@ -72,18 +73,22 @@ def god(string):
         eq = limit1(limit5(eq))
     if any(contain2(eq, "f_"+item) for item in "adj det list transpose".split(" ")):
            eq = matrix_formula(eq)
-           print(eq)
+           if debug:
+               print(eq)
            eq = matrix_solve(eq)
-           print(eq)
+           if debug:
+               print(eq)
            eq = solve_subs(eq)
-           print(f"=> {eq}")
-           print()
+           if debug:
+               print(f"=> {eq}")
+               print()
            return eq
     elif all(not contain2(eq, "f_"+item) for item in "dif add mul abs pow dif integrate arcsin sin cos log limit eq lt le ge gt".split(" ")) and\
        any(contain2(eq, "f_"+item) for item in "and or not imply equiv".split(" ")):
         eq = solve_logically(truth_gen(simplify(set_sub(eq))))
-        print(f"=> {eq}")
-        print()
+        if debug:
+            print(f"=> {eq}")
+            print()
         return eq
     elif not (eq.name == "f_and" and len(vlist(eq)) > 1) and any(contain2(eq, "f_"+item) for item in "eq lt le ge gt".split(" ")) and all(not contain2(eq, "f_"+item) for item in "limit dif integrate".split(" ")):
         lst = [simplify, log0, simplify, lambda x: dowhile(x, absolute), lambda x: dowhile(x, lambda y: simplify(expand(y))), lambda x: dowhile(x, lambda y: simplify(fraction(y))), logic0, simple_wavycurvy, simple_wavycurvy]
@@ -98,10 +103,11 @@ def god(string):
             eq = item(eq)
             if eq not in log:
                 log.append(eq)
-                print(eq)
-        # eq = trig7(eq)
-        print(f"=> {eq}")
-        print()
+                if debug:
+                    print(eq)
+        if debug:
+            print(f"=> {eq}")
+            print()
         return eq
     elif "f_dif" in str_form(eq) or "f_integrate" in str_form(eq):
         if "f_dif" in str_form(eq) and "f_integrate" not in str_form(eq):
@@ -109,12 +115,15 @@ def god(string):
             log.append(eq)
         if "f_integrate" in str_form(eq):
             eq = def_integrate_formula(eq)
-            eq = integrate_full(eq)
+            eq = integrate_full(eq, debug)
             eq = limit5(eq)
             eq = limit1(eq)
         eq = simplify(expand(simplify(eq)))
-        print(f"=> {eq}")
-        print()
+        if contain2(eq, "f_integrate"):
+            return None
+        if debug:
+            print(f"=> {eq}")
+            print()
         return eq
     if any("f_"+item in str_form(eq) for item in "eq lt le ge gt".split(" ")):
         eq = simple_wavycurvy(eq)
@@ -122,13 +131,15 @@ def god(string):
         out = linear_solve(eq)
         if out is not None:
             eq = out
-        print(eq)
+        if debug:
+            print(eq)
         eq = solve_subs(eq)
         out = linear_solve(eq)
         if out is not None:
             eq = out
         eq = simple_wavycurvy(eq)
     eq = simplify(expand(simplify(fraction(simplify(eq)))))
-    print(f"=> {eq}")
-    print()
+    if debug:
+        print(f"=> {eq}")
+        print()
     return eq

{mathai-2.3.7 → mathai-2.3.9}/mathai/integrate.py

@@ -8,7 +8,7 @@ from .fraction import fraction
 from .simplify import simplify
 from .expand import expand
 from .base import *
-from .formula_applier import formula_list_applier
+from .formula_applier import formula_list_applier, formula_applier
 from .inverse import inverse
 from .tool import poly
 from fractions import Fraction
@@ -36,6 +36,8 @@ def subs_heuristic(eq, var):
         if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) == Fraction(1,2):
             if eq.children[0] == var:
                 output.append(str_form(eq))
+        if eq.name == "f_log":
+            output.append(str_form(eq))
         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))
@@ -66,25 +68,27 @@ 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
-    
+    poly_size = -1
     fx = is_integrate_subs
     output = []
     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
+                if len(item) > poly_size:
+                    poly_term = item
+                    poly_size = len(item)
             else:
                 output.append(item)
     p = None
     if poly_term is None:
         p = tmp
     else:
-        p = output+[poly_term]
+        p = [poly_term]+output
     last = list(set(last))
-    if len(p)>3:
-        p = p[:3]
-    elif len(p)<3:
-        p = (p+last)[:3]
+    if len(p)>2:
+        p = p[:2]
+    elif len(p)<2:
+        p = (p+last)[:2]
     return p
 try_index = []
 try_lst = []
@@ -176,12 +180,14 @@ def integrate_subs(equation, term, v1, v2, extra):
     equation = simplify(equation)
     eq = equation
     termeq = term
-    t = inverse(copy.deepcopy(termeq), v1)
-    g = inverse(copy.deepcopy(termeq), v2)
+    t = inverse(termeq, v1)
+    g = inverse(termeq, v2)
     if g is None:
         return none
     if t is None:
-        return none
+        equation = simplify(factor2(factor0(simplify(replace(eq, g, tree_form(v2))/diff(g, v1)))))
+        if v1 in str_form(equation):        
+            return none
     else:
         t = expand(t)
         eq3 = diff(g, v1)
@@ -193,6 +199,9 @@ def integrate_subs(equation, term, v1, v2, extra):
             eq = replace(eq, tree_form(v1), t)
             equation = eq/eq3
             equation = simplify(equation)
+            if v1 in str_form(equation):
+                equation = replace(equation, tree_form(v1), t)
+                equation = formula_applier(equation, "abs(x) x [] _ _ _ _")
     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))))
@@ -308,30 +317,33 @@ def normalize(x, f=True):
     if f:
         x = dowhile(x, lambda y: fraction(simplify(integrate_formula(y))))
     else:
-        x = dowhile(x, lambda y: simplify(integrate_formula(y)))
+        x = integrate_formula(x)
     out = integrate_fraction(x)
     if out is not None:
         x = out
     return x
 
-def integrate_full(root):
+def integrate_full(root, debug=True):
     root = trig0(root)
     def is_solved(x):
         x = solve_integrate(x)
         return "f_integrate" not in str_form(x)
     result = None
     root = normalize(root)
+    root = formula_applier(root, "(a^b)^c a^(b*c) [] b c _ _")
     normalize2 = lambda x: normalize(x, False)
     log = []
     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, integrate_trig_formula, trig1, apart, normalize2],\
-                 [normalize, integrate_subs_main, normalize2, expand, normalize, byparts, normalize], [simplify, integrate_trig_formula, trig1, integrate_formula]]:
+                 [normalize2, integrate_subs_main, expand, normalize, factor2, simplify, apart, normalize, expand, byparts, normalize],\
+                 [simplify, integrate_trig_formula, trig1, integrate_formula]]:
         for item2 in item:
             eq = item2(eq)
             if eq not in log:
-                print(eq)
+                if debug:
+                    print(eq)
                 log.append(eq)
             if is_solved(eq):
                 result = eq

mathai-2.3.9/mathai/ncert_data.txt

@@ -0,0 +1,61 @@
+integrate(cos(2*x),x)
+integrate(3*x^2+4*x^3,x)
+integrate(1/x,x)
+integrate((x^3-1)/x^2,x)
+integrate(x^(2/3)+1,x)
+integrate(x^(3/2)+2*e^x-1/x,x)
+integrate(sin(x)+cos(x),x)
+integrate(cosec(x)*(cosec(x)+cot(x)),x)
+integrate((1-sin(x))/cos(x)^2,x)
+integrate(sin(2*x),x)
+integrate(cos(3*x),x)
+integrate(e^(2*x),x)
+integrate((a*x+b)^2,x)
+integrate(sin(2*x)-4*e^(3*x),x)
+integrate(4*e^(3*x)+1,x)
+integrate(x^2*(1-1/x^2),x)
+integrate(a*x^2+b*x+c,x)
+integrate(2*x^2+e^x,x)
+integrate((sqrt(x)-1/sqrt(x))^2,x)
+integrate((x^3+5*x^2-4)/x^2,x)
+integrate((x^3+3*x+4)/sqrt(x),x)
+integrate((x^3-x^2+x-1)/(x-1),x)
+integrate((1-x)*sqrt(x),x)
+integrate(sqrt(x)*(3*x^2+2*x+3),x)
+integrate(2*x-3*cos(x)+e^x,x)
+integrate(2*x^2-3*sin(x)+5*sqrt(x),x)
+integrate(sec(x)*(sec(x)+tan(x)),x)
+integrate(sec(x)^2/cosec(x)^2,x)
+integrate((2-3*sin(x))/cos(x)^2,x)
+integrate(sqrt(x)+1/sqrt(x),x)
+integrate(sin(x)^3*cos(x)^2,x)
+integrate(sin(x)/sin(x+a),x)
+integrate(1/(1+tan(x),x)
+integrate((e^(2*x)-1)/(e^(2*x)+1),x)
+integrate((e^(2*x)-e^(-2*x))/(e^(2*x)+e^(-2*x)),x)
+integrate(tan(2*x-3)^2,x)
+integrate(sec(7-4*x)^2,x)
+integrate(arcsin(x)/sqrt(1-x^2),x)
+integrate((2*cos(x)-3*sin(x))/(6*cos(x)+4*sin(x)),x)
+integrate((4*x+2)*sqrt(x^2+x+1),x)
+integrate(1/(x-sqrt(x)),x)
+integrate(1/(x*log(x)^m),x)
+integrate(e^arctan(x)/(1+x^2),x)
+integrate(x/e^(x^2),x)
+integrate(e^(2*x+3),x)
+integrate(x/(9-4*x^2),x)
+integrate(x^2/(2+3*x^3)^3,x)
+integrate((x^3-1)^(1/3)*x^5,x)
+integrate(x/sqrt(x+4),x)
+integrate(x*sqrt(1+2*x^2),x)
+integrate(x*sqrt(x+2),x)
+integrate(sqrt(a*x+b),x)
+integrate(sin(a*x+b)*cos(a*x+b),x)
+integrate(sin(cos(x))*sin(x),x)
+integrate(2*x/(1+x^2),x)
+integrate(log(x)^2/x,x)
+integrate(1/(x+log(x)*x),x)
+integrate(tan(sqrt(x))^4*sec(sqrt(x))^2/sqrt(x),x)
+integrate(sin(arctan(x))/(1+x^2),x)
+integrate(2*x*sin(x^2+1),x)
+integrate(sin(m*x),x)

{mathai-2.3.7 → mathai-2.3.9}/mathai.egg-info/PKG-INFO

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

{mathai-2.3.7 → mathai-2.3.9}/mathai.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ setup.py
 mathai/__init__.py
 mathai/apart.py
 mathai/base.py
+mathai/benchmark.py
 mathai/decision.py
 mathai/diff.py
 mathai/electronic.py
@@ -21,6 +22,7 @@ mathai/logic.py
 mathai/matrix.py
 mathai/ml.py
 mathai/mlscalar.py
+mathai/ncert_data.txt
 mathai/ode.py
 mathai/parser.py
 mathai/pde.py

{mathai-2.3.7 → mathai-2.3.9}/setup.py

@@ -3,11 +3,15 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="2.3.7",
+    version="2.3.9",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",
     url="https://github.com/infinity390/mathai",
     packages=find_packages(),
+    include_package_data=True,
+    package_data={
+        "mathai": ["ncert_data.txt"],
+    },
     python_requires=">=3.7",
 )