mathai 2.4.9__tar.gz → 2.5.0__tar.gz

{mathai-2.4.9 → mathai-2.5.0}/PKG-INFO

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

{mathai-2.4.9 → mathai-2.5.0}/mathai/__init__.py

@@ -9,7 +9,7 @@ from .graphics import draw_graphics_from_solution, solve_graphics, solve_graphic
 
 from .square_root import solve_sqrt
 
-from .benchmark import benchmark
+from .benchmark import benchmark, god2, benchmark_test
 
 from .formula_compiler import formula_compiler
 from .formula_compiler import formula_list_compiler
@@ -22,7 +22,7 @@ from .linear import linear_solve
 
 from .test import test
 
-from .decision import god, god2
+from .decision import god
 
 from .expand import expand
 

{mathai-2.4.9 → mathai-2.5.0}/mathai/benchmark.py

@@ -1,5 +1,6 @@
 import copy
 from pathlib import Path
+import concurrent.futures
 
 from .simplify import simplify
 from .expand import expand
@@ -20,9 +21,16 @@ from .limit import limit1
 from .logic import logic0
 from .base import *
 
+def _no_integrate_left(eq):
+    return eq.name == "f_range" or eq.name == "s_true" or all(not contain2(eq, "f_"+item) for item in "eq integrate subs limit limitpinf limitninf".split(" "))
+
+# Top-level helper function for picklability in multiprocessing
+def run_absolute(x):
+    return dowhile(x, absolute)
+
 
 fx_list = [
-    lambda x: dowhile(x, absolute),
+    run_absolute,
     logic0,
     limit1,
     simple_wavycurvy,
@@ -52,45 +60,6 @@ integrate_clean apart trig0 trig1 trig4 integrate_fraction factor2 trig6
 FUNCS = dict(zip(name_list, fx_list))
 
 
-# ---------------------------------------------------------------------------
-# Benchmark
-# ---------------------------------------------------------------------------
-
-
-def benchmark(s="ncert_data"):
-    data_path = Path(__file__).parent / f"{s}.txt"
-    output_path = Path(__file__).parent / f"{s}_optimized.txt"
-
-    optimized_lines = []
-
-    with open(data_path, "r", encoding="utf-8") as file:
-        for count, line in enumerate(file, 1):
-            parts = line.split()
-
-            if not parts:
-                continue
-
-            expr_str, *function_names = parts
-            eq = simplify(parse(expr_str))
-            effective_steps = [expr_str]
-
-            for func_name in function_names:
-                func = FUNCS[func_name]
-                prev_eq = copy.deepcopy(eq)
-                eq = func(eq)
-
-                if eq != prev_eq:
-                    effective_steps.append(func_name)
-
-            print(f"{count}. {expr_str} => {eq}")
-            optimized_lines.append(" ".join(effective_steps))
-
-    with open(output_path, "w", encoding="utf-8") as file:
-        file.write("\n".join(optimized_lines) + "\n")
-
-    print(f"\nOptimized dataset successfully written to: {output_path}")
-
-
 # ---------------------------------------------------------------------------
 # Strategy tree
 # ---------------------------------------------------------------------------
@@ -173,7 +142,7 @@ def print_tree(node, depth=0):
 
 
 # ---------------------------------------------------------------------------
-# Serial Execution Entry Point
+# Serial & Parallel Execution Entry Points
 # ---------------------------------------------------------------------------
 
 
@@ -193,3 +162,136 @@ def execute_serial(tree, equation, terminal_condition=None):
                 return [(eq, seq)]
 
     return []
+
+
+def _execute_child_worker(args):
+    """Worker helper function for parallel execution across cores."""
+    child, equation, terminal_condition = args
+    try:
+        return child.execute(copy.deepcopy(equation), [], terminal_condition)
+    except Exception:
+        return []
+
+
+def execute_parallel(tree, equation, terminal_condition=None):
+    """
+    Splits the strategy tree root node's children and distributes 
+    them across multiple CPU cores using ProcessPoolExecutor.
+    """
+    children = list(tree.children.values())
+    if not children:
+        return []
+
+    tasks = [(child, equation, terminal_condition) for child in children]
+
+    with concurrent.futures.ProcessPoolExecutor() as executor:
+        futures = [executor.submit(_execute_child_worker, task) for task in tasks]
+        
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                results = future.result()
+                for eq, seq in results:
+                    if terminal_condition is None or terminal_condition(eq):
+                        return [(eq, seq)]
+            except Exception:
+                continue
+
+    return []
+
+
+def god2(string, parallel=False):
+    tree = strategy_tree(load_sequences("ncert_data"))
+    if parallel:
+        out = execute_parallel(tree, simplify(parse(string)), _no_integrate_left)
+    else:
+        out = execute_serial(tree, simplify(parse(string)), _no_integrate_left)
+    if len(out) >= 1:
+        print(string)
+        print("=>", out[0][0])
+        print(["parse", "simplify"] + out[0][1])
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Benchmark Test (Pure Execution, No Writing, No Strategy Trees)
+# ---------------------------------------------------------------------------
+
+
+def benchmark_test(s="ncert_data"):
+    data_path = Path(__file__).parent / f"{s}.txt"
+
+    with open(data_path, "r", encoding="utf-8") as file:
+        for count, line in enumerate(file, 1):
+            parts = line.split()
+
+            if not parts:
+                continue
+
+            expr_str, *function_names = parts
+            eq = simplify(parse(expr_str))
+
+            for func_name in function_names:
+                func = FUNCS[func_name]
+                prev_eq = copy.deepcopy(eq)
+                eq = func(eq)
+
+            print(f"{count}. {expr_str} => {eq}")
+
+    print(f"\nBenchmark test execution completed for: {s}.txt")
+
+
+# ---------------------------------------------------------------------------
+# Benchmark
+# ---------------------------------------------------------------------------
+
+
+def benchmark(s="ncert_data"):
+    data_path = Path(__file__).parent / f"{s}.txt"
+    output_path = Path(__file__).parent / f"{s}_optimized.txt"
+
+    optimized_lines = []
+    
+    # Initialize an empty strategy tree
+    tree = Node("ROOT")
+
+    with open(data_path, "r", encoding="utf-8") as file:
+        for count, line in enumerate(file, 1):
+            parts = line.split()
+
+            if not parts:
+                continue
+
+            expr_str, *function_names = parts
+            eq_parsed = simplify(parse(expr_str))
+
+            # Try solving with the strategy tree built so far
+            out = execute_serial(tree, eq_parsed, _no_integrate_left)
+
+            if len(out) >= 1:
+                # Solved successfully by the strategy tree: DO NOT update tree, exclude from optimized file
+                print(f"{count}.", expr_str, "=>", out[0][0])
+                continue
+
+            # Strategy tree failed: fall back to manual function sequence
+            eq = eq_parsed
+            effective_steps = [expr_str]
+
+            for func_name in function_names:
+                func = FUNCS[func_name]
+                prev_eq = copy.deepcopy(eq)
+                eq = func(eq)
+                if eq != prev_eq:
+                    effective_steps.append(func_name)
+
+            # Update the strategy tree ONLY because it failed
+            current_node = tree
+            for func_name in effective_steps[1:]:
+                current_node = current_node.add_child(func_name)
+
+            print(f"{count}. {expr_str} => {eq} **")
+            optimized_lines.append(" ".join(effective_steps))
+
+    with open(output_path, "w", encoding="utf-8") as file:
+        file.write("\n".join(optimized_lines) + "\n")
+
+    print(f"\nOptimized dataset successfully written to: {output_path}")

{mathai-2.4.9 → mathai-2.5.0}/mathai/decision.py

@@ -15,7 +15,6 @@ from .factor import factor2, factor
 from .limit import limit1, limit5
 from .linear import linear_solve
 from .matrix import matrix_solve, matrix_formula
-from .benchmark import load_sequences, strategy_tree, execute_serial
 
 def vlist_2(eq):
     out = []
@@ -61,21 +60,6 @@ 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 _no_integrate_left(eq):
-    return eq.name == "f_range" or eq.name == "s_true" or all(not contain2(eq, "f_"+item) for item in "eq integrate subs limit limitpinf limitninf".split(" "))
-
-
-def god2(string):
-    out = execute_serial(
-        strategy_tree(load_sequences("ncert_data")),
-        simplify(parse(string)),
-        _no_integrate_left,
-    )
-    if len(out) >= 1:
-        print(string)
-        print("=>", out[0][0])
-        print(["parse", "simplify"] + out[0][1])
-    return None
 
 def god(string, debug=True):
     if debug:

{mathai-2.4.9 → mathai-2.5.0}/mathai/ncert_data.txt

@@ -1,5 +1,7 @@
-abs(3*x-5)+abs(8-x)=abs(3+2*x) absolute simplify simple_wavycurvy
-(sin(x)+cosec(x))^2+(cos(x)+sec(x))^2=7+tan(x)^2+cot(x)^2 trig0 fraction trig1 fraction simplify trig1 logic0
+(x+1)*(x-1)=x^2-1 expand simplify logic0
+(a+b)^2=a^2+b^2+2*a*b expand simplify logic0
+1+1=2 logic0
+sin(x)^2+cos(x)^2=1 trig1 simplify logic0
 (1/(1-4*i)-2/(1+i))*((3-4*i)/(5+i))
 limit((1-cos(x))/x,x) limit1
 limit(sin(4*x)/sin(2*x),x) limit1
@@ -62,3 +64,5 @@ integrate(log(x)^2/x,x) integrate_subs integrate_formula integrate_clean
 integrate(sin(arctan(x))/(1+x^2),x) integrate_subs integrate_formula integrate_clean
 integrate(2*x*sin(x^2+1),x) integrate_formula integrate_subs integrate_formula integrate_clean
 integrate(sin(m*x),x) integrate_formula
+abs(3*x-5)+abs(8-x)=abs(3+2*x) absolute simplify simple_wavycurvy
+(sin(x)+cosec(x))^2+(cos(x)+sec(x))^2=7+tan(x)^2+cot(x)^2 trig0 fraction trig1 fraction simplify trig1 logic0

mathai-2.5.0/mathai/ncert_data_optimized.txt

@@ -0,0 +1,22 @@
+(x+1)*(x-1)=x^2-1 expand simplify logic0
+1+1=2 logic0
+sin(x)^2+cos(x)^2=1 trig1 logic0
+(1/(1-4*i)-2/(1+i))*((3-4*i)/(5+i))
+limit((1-cos(x))/x,x) limit1
+4*x+3<6*x+7 simple_wavycurvy
+integrate(x/((x+1)*(x+2)),x) apart integrate_formula
+integrate(sin(2*x+5)^2,x) trig1 integrate_formula
+integrate((1-cos(x))/(1+cos(x)),x) trig6 expand integrate_formula integrate_trig_formula simplify integrate_trig_formula integrate_formula
+integrate(sin(x)/(1+cos(x)),x) trig6 expand integrate_formula simplify integrate_trig_formula
+integrate(cos(2*x),x) integrate_formula
+integrate(cosec(x)*(cosec(x)+cot(x)),x) trig0 fraction expand integrate_formula simplify integrate_trig_formula
+integrate((1-sin(x))/cos(x)^2,x) expand integrate_formula integrate_trig_formula
+integrate(x^2*(1-1/x^2),x) expand simplify integrate_formula
+integrate(sec(x)^2/cosec(x)^2,x) trig0 simplify integrate_trig_formula integrate_formula trig1
+integrate(sin(x)/sin(x+a),x) integrate_subs expand simplify integrate_formula integrate_trig_formula integrate_clean
+integrate((e^(2*x)-1)/(e^(2*x)+1),x) integrate_subs integrate_formula expand simplify apart integrate_formula integrate_clean
+integrate((e^(2*x)-e^(-2*x))/(e^(2*x)+e^(-2*x)),x) integrate_subs integrate_formula fraction simplify apart integrate_formula integrate_fraction integrate_clean
+integrate(tan(2*x-3)^2,x) trig0 integrate_trig_formula integrate_formula
+integrate((4*x+2)*sqrt(x^2+x+1),x) integrate_subs integrate_formula integrate_clean
+abs(3*x-5)+abs(8-x)=abs(3+2*x) absolute simplify simple_wavycurvy
+(sin(x)+cosec(x))^2+(cos(x)+sec(x))^2=7+tan(x)^2+cot(x)^2 trig0 fraction trig1 fraction simplify trig1 logic0

{mathai-2.4.9 → mathai-2.5.0}/mathai/univariate_inequality.py

@@ -607,6 +607,7 @@ def simple_wavycurvy(eq, mode=False):
     eq = factor2(eq)
     eq = simplify(eq, True, True)
     eq = wavycurvy(eq, mode)
+    eq = solve_sqrt(eq)
     if eq.name == "f_range":
         tmp = eq2range(eq).truth()
         if tmp == 1:

{mathai-2.4.9 → mathai-2.5.0}/mathai.egg-info/PKG-INFO

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

{mathai-2.4.9 → mathai-2.5.0}/mathai.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ mathai/matrix.py
 mathai/ml.py
 mathai/mlscalar.py
 mathai/ncert_data.txt
+mathai/ncert_data_optimized.txt
 mathai/ode.py
 mathai/parser.py
 mathai/pde.py

{mathai-2.4.9 → mathai-2.5.0}/setup.py

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