mathai 2.4.6__tar.gz → 2.4.7__tar.gz

{mathai-2.4.6 → mathai-2.4.7}/PKG-INFO

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

{mathai-2.4.6 → mathai-2.4.7}/mathai/__init__.py

@@ -1,3 +1,5 @@
+from .benchmark import load_sequences, strategy_tree, execute_parallel
+
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 
@@ -20,7 +22,7 @@ from .linear import linear_solve
 
 from .test import test
 
-from .decision import god
+from .decision import god, god2
 
 from .expand import expand
 

mathai-2.4.7/mathai/benchmark.py

@@ -0,0 +1,312 @@
+import atexit
+import copy
+import multiprocessing
+from pathlib import Path
+
+from .simplify import simplify
+from .expand import expand
+from .parser import parse
+from .fraction import fraction
+from .apart import apart
+from .integrate import (
+    integrate_formula,
+    integrate_trig_formula,
+    integrate_fraction,
+    integrate_subs_main as integrate_subs,
+    solve_integrate as integrate_clean,
+)
+from .factor import factor2
+from .trig import trig0, trig1, trig4, trig6
+from .univariate_inequality import simple_wavycurvy, absolute
+from .limit import limit1
+from .logic import logic0
+from .base import *
+
+
+fx_list = [
+    lambda x: dowhile(x, absolute),
+    logic0,
+    limit1,
+    simple_wavycurvy,
+    simplify,
+    expand,
+    fraction,
+    integrate_formula,
+    integrate_subs,
+    integrate_trig_formula,
+    integrate_clean,
+    apart,
+    trig0,
+    trig1,
+    trig4,
+    integrate_fraction,
+    factor2,
+    trig6,
+]
+
+name_list = """
+absolute logic0 limit1 simple_wavycurvy simplify expand fraction
+integrate_formula integrate_subs integrate_trig_formula
+integrate_clean apart trig0 trig1 trig4 integrate_fraction factor2 trig6
+""".split()
+
+# O(1) name -> function lookup
+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
+# ---------------------------------------------------------------------------
+
+
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.children = {}  # Dictionary for O(1) child lookup
+
+    def add_child(self, value):
+        if value not in self.children:
+            self.children[value] = Node(value)
+        return self.children[value]
+
+    def execute(self, equation, sequence=None, terminal_condition=None):
+        if sequence is None:
+            sequence = []
+
+        if self.value != "ROOT":
+            func = FUNCS[self.value]
+
+            # Track previous state to detect and prune no-ops
+            prev_eq = copy.deepcopy(equation)
+            equation = func(equation)
+
+            # PRUNING: if the function didn't change the equation, halt this branch
+            if equation == prev_eq:
+                return []
+
+            sequence = sequence + [self.value]
+
+            # Check terminal condition after applying the function
+            if terminal_condition is not None and terminal_condition(equation):
+                return [(equation, sequence)]
+
+        if not self.children:
+            return [(equation, sequence)]
+
+        results = []
+        for child in self.children.values():
+            results.extend(
+                child.execute(copy.deepcopy(equation), sequence, terminal_condition)
+            )
+
+        return results
+
+
+def strategy_tree(sequences):
+    root = Node("ROOT")
+
+    for sequence in sequences:
+        node = root
+
+        for function_name in sequence:
+            node = node.add_child(function_name)
+
+    return root
+
+
+def load_sequences(s="ncert_data"):
+    data_path = Path(__file__).parent / f"{s}.txt"
+    sequences = []
+
+    with open(data_path, "r", encoding="utf-8") as file:
+        for line in file:
+            parts = line.split()
+
+            if parts:
+                sequences.append(parts[1:])
+
+    return sequences
+
+
+def print_tree(node, depth=0):
+    print("  " * depth + str(node.value))
+
+    for child in node.children.values():
+        print_tree(child, depth + 1)
+
+
+# ---------------------------------------------------------------------------
+# Parallel execution
+#
+# Design: nothing heavy is pickled per call.
+#   - Each worker builds the tree once, from the dataset name, at pool start.
+#   - Terminal conditions are looked up by name in TERMINAL_CONDITIONS, so no
+#     function object is ever sent to a worker.
+#   - Pools persist across calls, so spawn/import cost is paid once.
+#   - Per task, only (branch index, equation, condition name, generation)
+#     is sent.
+# ---------------------------------------------------------------------------
+
+# Register terminal conditions here. Workers re-import this module and find
+# them by name.
+TERMINAL_CONDITIONS = {
+    "no_integrate": lambda eq: not contain2(eq, "f_integrate"),
+}
+
+_TREES = {}  # data_name -> root Node (cached per process)
+_POOLS = {}  # (data_name, n_cores) -> (pool, generation counter)
+
+# Worker-process globals, set once by _init_worker
+_W_BRANCHES = None
+_W_GEN = None
+
+
+def _get_tree(data_name):
+    if data_name not in _TREES:
+        _TREES[data_name] = strategy_tree(load_sequences(data_name))
+    return _TREES[data_name]
+
+
+def _init_worker(data_name, gen):
+    global _W_BRANCHES, _W_GEN
+    _W_BRANCHES = list(_get_tree(data_name).children.values())
+    _W_GEN = gen
+
+
+def _worker(task):
+    idx, equation, cond_name, my_gen = task
+
+    # Stale task left over from a call that already finished: skip it.
+    if _W_GEN.value != my_gen:
+        return []
+
+    cond = TERMINAL_CONDITIONS[cond_name] if cond_name else None
+    try:
+        return _W_BRANCHES[idx].execute(equation, [], cond)
+    except Exception:
+        # A failing branch must not discard results from other branches.
+        return []
+
+
+def _first_match(results, cond):
+    for eq, seq in results:
+        if cond is None or cond(eq):
+            return [(eq, seq)]
+    return None
+
+
+def _execute_sequential(data_name, equation, cond_name):
+    cond = TERMINAL_CONDITIONS[cond_name] if cond_name else None
+
+    for child in _get_tree(data_name).children.values():
+        try:
+            results = child.execute(copy.deepcopy(equation), [], cond)
+        except Exception:
+            continue  # same semantics as the workers
+
+        match = _first_match(results, cond)
+        if match is not None:
+            return match
+
+    return []
+
+
+def _get_pool(data_name, n_cores):
+    key = (data_name, n_cores)
+
+    if key not in _POOLS:
+        gen = multiprocessing.Value("i", 0, lock=False)
+        pool = multiprocessing.Pool(
+            n_cores, initializer=_init_worker, initargs=(data_name, gen)
+        )
+        _POOLS[key] = (pool, gen)
+
+    return _POOLS[key]
+
+
+def shutdown_pools():
+    for pool, _ in _POOLS.values():
+        pool.terminate()
+        pool.join()
+    _POOLS.clear()
+
+
+atexit.register(shutdown_pools)
+
+
+def execute_parallel(data_name, equation, n_cores=None, condition_name=None):
+    """
+    Run the strategy tree for `data_name` against `equation` and return at
+    most one result as a one-item list [(equation, sequence)].
+
+    condition_name: key into TERMINAL_CONDITIONS, or None.
+
+    On Windows/macOS (spawn start method) callers using n_cores > 1 must be
+    guarded by ``if __name__ == "__main__":``.
+    """
+    n_branches = len(_get_tree(data_name).children)
+    if n_branches == 0:
+        return []
+
+    if n_cores is None:
+        n_cores = multiprocessing.cpu_count()
+    # Never more processes than branches, never fewer than one
+    n_cores = max(1, min(n_cores, n_branches))
+
+    if n_cores == 1:
+        return _execute_sequential(data_name, equation, condition_name)
+
+    cond = TERMINAL_CONDITIONS[condition_name] if condition_name else None
+    pool, gen = _get_pool(data_name, n_cores)
+
+    my_gen = gen.value + 1
+    gen.value = my_gen
+    tasks = [(i, equation, condition_name, my_gen) for i in range(n_branches)]
+
+    try:
+        for branch_results in pool.imap_unordered(_worker, tasks):
+            match = _first_match(branch_results, cond)
+            if match is not None:
+                return match
+        return []
+    finally:
+        gen.value = my_gen + 1  # cancels any still-queued tasks

{mathai-2.4.6 → mathai-2.4.7}/mathai/decision.py

@@ -15,6 +15,7 @@ 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_parallel
 
 def vlist_2(eq):
     out = []
@@ -60,6 +61,20 @@ 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 god2(string, core=1):
+    out = execute_parallel(
+        "ncert_data", simplify(parse(string)), core, "no_integrate"
+    )
+
+    if len(out) >= 1:
+        print(string)
+        print("=>", out[0][0])
+        print(["parse", "simplify"] + out[0][1])
+
+    return out
+
 def god(string, debug=True):
     if debug:
         print(f"? {string}")

{mathai-2.4.6 → mathai-2.4.7}/mathai.egg-info/PKG-INFO

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

{mathai-2.4.6 → mathai-2.4.7}/setup.py

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

mathai-2.4.6/mathai/benchmark.py

@@ -1,63 +0,0 @@
-import random
-import copy
-from pathlib import Path
-from .simplify import simplify
-from .expand import expand
-from .parser import parse
-from .fraction import fraction
-from .apart import apart
-from .integrate import integrate_formula, integrate_trig_formula, integrate_fraction
-from .integrate import integrate_subs_main as integrate_subs
-from .integrate import solve_integrate as integrate_clean
-from .factor import factor2
-from .trig import trig0, trig1, trig4, trig6
-from .univariate_inequality import simple_wavycurvy, absolute
-from .limit import limit1
-from .logic import logic0
-from .base import *
-
-fx_list = [lambda x: dowhile(x, absolute), logic0, limit1, simple_wavycurvy, simplify, expand, fraction, integrate_formula, integrate_subs, integrate_trig_formula, integrate_clean, apart, trig0, trig1, trig4, integrate_fraction, factor2, trig6]
-name_list = "absolute, logic0, limit1, simple_wavycurvy, simplify, expand, fraction, integrate_formula, integrate_subs, integrate_trig_formula, integrate_clean, apart, trig0, trig1, trig4, integrate_fraction, factor2, trig6".split(", ")
-
-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:
-        content = file.read().strip().split("\n")
-        count = 0
-        for item in content:
-            count += 1
-            item = item.strip()
-            if not item:
-                continue
-            parts = item.split(" ")
-            expr_str = parts[0]
-            eq = simplify(parse(expr_str))
-            
-            effective_steps = [expr_str]
-            
-            for func_name in parts[1:]:
-                func_idx = name_list.index(func_name)
-                func = fx_list[func_idx]
-                
-                # Deepcopy to avoid in-place mutation reference traps
-                prev_eq = copy.deepcopy(eq)
-                eq = func(eq)
-                
-                # Check if the function changed the equation
-                if eq == prev_eq:
-                    pass
-                else:
-                    effective_steps.append(func_name)
-            
-            print(f"{count}. {expr_str} => {eq}")
-            optimized_lines.append(" ".join(effective_steps))
-            
-    # Write out the optimized lines without non-changing functions
-    with open(output_path, "w", encoding="utf-8") as outfile:
-        outfile.write("\n".join(optimized_lines) + "\n")
-        
-    print(f"\nOptimized dataset successfully written to: {output_path}")