mathai 2.3.8__tar.gz → 2.4.0__tar.gz

{mathai-2.3.8 → mathai-2.4.0}/PKG-INFO

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

{mathai-2.3.8 → mathai-2.4.0}/mathai/__init__.py

@@ -7,6 +7,11 @@ 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 .formula_compiler import formula_compiler
+from .formula_compiler import formula_list_compiler
+
 from .lambda_calculus import lambda_expand, lambda_compress, lambda_reduce
 
 from .electronic import Edge, CircuitGraph, find_resistance

{mathai-2.3.8 → mathai-2.4.0}/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.4.0/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.8 → mathai-2.4.0}/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.4.0/mathai/diff.py

@@ -0,0 +1,24 @@
+from .simplify import simplify
+from .base import *
+from .parser import parse
+from .formula_compiler import formula_list_compiler
+
+diff2_s = """pdif(e^a,x) e^a*pdif(a,x) [] x _ _ _
+pdif(a^b,x) b*(a^(b-1))*pdif(a,x)+(a^b)*log(a)*pdif(b,x) [] x _ _ _
+pdif(sin(a),x) cos(a)*pdif(a,x) [] x _ _ _
+pdif(cos(a),x) -sin(a)*pdif(a,x) [] x _ _ _
+pdif(arcsin(a),x) (1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
+pdif(arccos(a),x) (-1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
+pdif(arctan(a),x) (1/(1+a^2))*pdif(a,x) [] x _ _ _
+pdif(k,x) 0 [] x k _ _
+pdif(x,x) 1 [] x _ _ _
+pdif(product(a,b),x) pdif(a,x)*b+a*pdif(b,x) [] x _ _ _
+pdif(sum(a,b),x) pdif(a,x)+pdif(b,x) [] x _ _ _
+pdif(product(k,a),x) k*pdif(a,x) [] x k _ _"""
+
+diff2 = formula_list_compiler(diff2_s)
+
+def diff(equation, var=None):
+    var = var if var else "v_0"
+    out = diff2(simplify(TreeNode("f_pdif", [equation, tree_form(var)])))
+    return out

{mathai-2.3.8 → mathai-2.4.0}/mathai/factor.py

@@ -7,9 +7,9 @@ import math
 from .tool import poly
 from .fraction import fraction
 from collections import Counter
-from .formula_applier import formula_list_applier
+from .formula_compiler import formula_list_compiler
 
-factor2 = lambda x: formula_list_applier(x, "poly(x,a,b,c) a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) [] _ _ b^2-4*a*c _")
+factor2 = formula_list_compiler("poly(x,a,b,c) a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a)) [] _ _ b^2-4*a*c _")
 def multiset_intersection(*lists):
     counters = list(map(Counter, lists))
     common = counters[0]

{mathai-2.3.8 → mathai-2.4.0}/mathai/formula_applier.py

@@ -705,6 +705,9 @@ def formula_list_applier(eq, s):
     return dowhile(eq, lambda x: formula_list_applier_h(x, s))
 
 
+def _is_zero(node):
+    return node is not None and (getattr(node, "name", None) == "d_0" or node == 0)
+
 def extract_polynomial_coefficients(eq, var, degree):
     if eq is None:
         return None
@@ -717,12 +720,14 @@ def extract_polynomial_coefficients(eq, var, degree):
         if c_val is None:
             return None
         coefficients.append(c_val)
-        simplified_num = simplify(operation("f_sub", [current_eq, c_val]))
-        if simplified_num == 0:
+        remainder = simplify(operation("f_sub", [current_eq, c_val]))
+        if remainder is None:
+            return None
+        if _is_zero(remainder):
             coefficients.extend(TreeNode("d_0") for _ in range(degree + 1 - len(coefficients)))
             return coefficients
-        current_eq = simplify(expand(simplify(operation("f_div", [simplified_num, var_node]))))
+        current_eq = simplify(expand(simplify(operation("f_div", [remainder, var_node]))))
         if current_eq is None:
             return None
     final_check = simplify(replace(copy.deepcopy(current_eq), var_node, zero_node))
-    return coefficients if final_check == 0 else None
+    return coefficients if _is_zero(final_check) else None