mathai 0.4.0__tar.gz → 0.4.2__tar.gz

{mathai-0.4.0 → mathai-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.0
+Version: 0.4.2
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Author: educated indians are having a low iq and are good for nothing

{mathai-0.4.0 → mathai-0.4.2}/mathai/__init__.py

@@ -36,8 +36,6 @@ from .console import console
 
 from .limit import limit
 
-from .search import dfs_simplify as search0
-
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
 
 from .base import *

{mathai-0.4.0 → mathai-0.4.2}/mathai/apart.py

@@ -1,14 +1,18 @@
 from .linear import linear_solve
 from .expand import expand
 from .simplify import simplify
+
 from .diff import diff
 from .inverse import inverse
 from .base import *
 import math
 from .tool import poly, enclose_const
 
-def _apart(eq, v="v_0"):
-    
+def _apart(eq, v=None):
+    if v is None:
+        if len(vlist(eq)) == 0:
+            return eq
+        v = vlist(eq)[0]
     origv = vlist(eq)
     eq = simplify(eq)
     if eq.name != "f_mul":
@@ -42,8 +46,9 @@ def _apart(eq, v="v_0"):
     s = []
     facd = [simplify(x) for x in factor_generation(simplify(d))]
     
-     
-    facd2 = remove_duplicates_custom(facd, lambda m, n: simplify(m-n) == tree_form("d_0"))
+    
+    facd2 = remove_duplicates_custom(facd, lambda m, n: simplify(expand(simplify(m-n))) == tree_form("d_0"))
+
     if len(facd2) == 1:
         return eq
     x = tree_form(v)
@@ -58,6 +63,7 @@ def _apart(eq, v="v_0"):
             if n > 2:
                 return eq
             n = tree_form("d_"+str(n))
+            
             l = len(poly(item, v))
             if l == 3:
                 a = alloclst.pop(0)
@@ -93,14 +99,15 @@ def _apart(eq, v="v_0"):
     final = summation(final2)
    
     s = simplify(TreeNode("f_eq", [final-eq2, tree_form("d_0")]))
-    
+
     lst = poly(s.children[0], v)
-    
+
     lst = [TreeNode("f_eq", [item, tree_form("d_0")]) for item in lst if "v_" in str_form(item)]
     lst2 = []
     for item in lst:
         lst2+=vlist(item)
     origv = list(set(lst2)-set(origv))
+    
     out = linear_solve(TreeNode("f_and", lst), [tree_form(item) for item in origv])
     for item in out.children:
         
@@ -108,6 +115,9 @@ def _apart(eq, v="v_0"):
     return simplify(final3)
 def apart(eq):
     eq, fx = enclose_const(eq)
-    
-    eq = _apart(eq)
-    return fx(eq)
+    def helper(eq):
+        eq2 = _apart(eq)
+        if eq != eq2:
+            return eq2
+        return TreeNode(eq.name, [helper(child) for child in eq.children])
+    return fx(helper(eq))

{mathai-0.4.0 → mathai-0.4.2}/mathai/base.py

@@ -131,6 +131,8 @@ def frac(eq):
         return Fraction(int(eq.name[2:]))
     if eq.name == "f_add":
         p = frac(eq.children[0])
+        if p is None:
+            return None
         for child in eq.children[1:]:
             tmp = frac(child)
             if isinstance(tmp, Fraction):
@@ -140,6 +142,8 @@ def frac(eq):
         return p
     if eq.name == "f_mul":
         p = frac(eq.children[0])
+        if p is None:
+            return None
         for child in eq.children[1:]:
             tmp = frac(child)
             if isinstance(tmp, Fraction):
@@ -286,6 +290,8 @@ def flatten_tree(node):
         node.children = [flatten_tree(child) for child in node.children]
         return node
 def dowhile(eq, fx):
+    if eq is None:
+        return None
     while True:
         orig = eq.copy_tree()
         eq2 = fx(eq)

{mathai-0.4.0 → mathai-0.4.2}/mathai/integrate.py

@@ -104,8 +104,6 @@ def handle_try(eq):
     else:
         return TreeNode(eq.name, [handle_try(child) for child in eq.children])
 def inteq(eq):
-    if "f_ref" not in str_form(eq):
-        return eq
     if eq.name == "f_try":
         eq2 = None
         output = []
@@ -113,13 +111,19 @@ def inteq(eq):
             if child.name == "f_ref":
                 eq2 = child.children[0]
                 break
+        if eq2 is None:
+            return eq
         for child in eq.children:
             if child.name == "f_ref":
                 output.append(child)
             else:
                 eq3 = simplify(expand(simplify(eq2 - child)))
                 if contain(eq3, eq2):
-                    output.append(inverse(eq3, str_form(eq2)))
+                    out = inverse(eq3, str_form(eq2))
+                    if out is None:
+                        output.append(child)
+                    else:
+                        output.append(out)
                 else:
                     output.append(child)
         return TreeNode("f_try", output)
@@ -128,13 +132,14 @@ def inteq(eq):
 def rm(eq):
     if eq.name == "f_try":
         eq = TreeNode(eq.name, list(set(eq.children)))
-    return TreeNode(eq.name, [rm(child) for child in eq.children])
+    return TreeNode(eq.name, [rm(child) for child in eq.children if child is not None])
 def solve_integrate(eq):
     
     eq2 = dowhile(eq, _solve_integrate)
     eq2 = dowhile(eq2, handle_try)
     eq2 = rm(eq2)
-    eq2.children = list(set(eq2.children))
+    if eq2.name == "f_try":
+        eq2.children = list(set(eq2.children))
     return eq2
 def integrate_subs(equation, term, v1, v2):
     output = []
@@ -165,7 +170,7 @@ def integrate_subs(equation, term, v1, v2):
         
         return none
 
-    return TreeNode("f_subs", [TreeNode("f_integrate", [simplify(expand(simplify(equation))), tree_form(origv2)]),tree_form(origv2) ,g])
+    return TreeNode("f_subs", [TreeNode("f_integrate", [simplify(fraction(expand(simplify(equation)))), tree_form(origv2)]),tree_form(origv2) ,g])
 
 def integrate_subs_main(equation):
     if equation.name == "f_ref":
@@ -291,7 +296,7 @@ def _sqint(equation):
     return coll
 
 def sqint(eq):
-    out = _sqint(eq)
+    out = simplify(_sqint(eq))
     if out is None:
         return eq
     return out
@@ -338,6 +343,7 @@ def integration_formula_init():
                     (f"e^(A*{var}+B)", f"e^(A*{var}+B)/A"),\
                     (f"1/cos({var})", f"log(abs((1+sin({var}))/cos({var})))"),\
                     (f"1/cos({var})^2", f"sin({var})/cos({var})"),\
+                    (f"1/sin({var})", f"log(abs(tan({var}/2)))"),\
                     (f"abs(A*{var}+B)", f"(A*{var}+B)*abs(A*{var}+B)/(2*A)")]
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A"), parse("1")], [parse("B"), parse("0")]]
@@ -376,6 +382,7 @@ def rm_const(equation):
                 return rm_const(TreeNode("f_integrate",[equation, wrt])) *const
         equation = eq2
     return TreeNode(equation.name, [rm_const(child)  for child in equation.children])
+
 def integrate_formula(equation):
     if equation.name == "f_ref":
         return equation.copy_tree()
@@ -384,17 +391,18 @@ def integrate_formula(equation):
         integrand = eq2.children[0]
         wrt = eq2.children[1]
         if integrand == wrt:
-            return TreeNode("f_add", [TreeNode("f_power", [wrt.copy_tree(), TreeNode("2")]), TreeNode("f_div", [TreeNode("1"), TreeNode("2")])])  # x^2/2
+            return wrt**2/2  # x^2/2
         if not contain(integrand, wrt):
-            return TreeNode("f_mul", [wrt.copy_tree(), integrand.copy_tree()])  # constant * dx
+            return integrand*wrt
         out = transform_formula(simplify(trig0(integrand)), wrt.name, formula_gen[0], formula_gen[1], formula_gen[2])
         if out is not None:
+            
             return out
         expr_str = str_form(integrand)
         if expr_str.count("f_sin") + expr_str.count("f_cos") > 2:
             out = transform_formula(integrand, wrt.name, formula_gen4[0], formula_gen4[1], formula_gen4[2])
             if out is not None:
-                print(out, 111)
+                
                 return out
     return TreeNode(eq2.name, [integrate_formula(child) for child in eq2.children])
 

{mathai-0.4.0 → mathai-0.4.2}/mathai/linear.py

@@ -3,6 +3,9 @@ from .simplify import simplify, solve
 from .fraction import fraction
 from .expand import expand
 from .base import *
+from .factor import factorconst
+def ss(eq):
+    return dowhile(eq, lambda x: fraction(expand(simplify(x))))
 def rref(matrix):
     rows, cols = len(matrix), len(matrix[0])
     lead = 0
@@ -10,7 +13,7 @@ def rref(matrix):
         if lead >= cols:
             return matrix
         i = r
-        while fraction(simplify(matrix[i][lead])) == tree_form("d_0"):
+        while ss(matrix[i][lead]) == tree_form("d_0"):
             i += 1
             if i == rows:
                 i = r
@@ -19,11 +22,11 @@ def rref(matrix):
                     return matrix
         matrix[i], matrix[r] = matrix[r], matrix[i]
         lv = matrix[r][lead]
-        matrix[r] = [fraction(simplify(m / lv)) for m in matrix[r]]
+        matrix[r] = [ss(m / lv) for m in matrix[r]]
         for i in range(rows):
             if i != r:
                 lv = matrix[i][lead]
-                matrix[i] = [fraction(simplify(m - lv * n)) for m, n in zip(matrix[i], matrix[r])]
+                matrix[i] = [ss(m - lv * n) for m, n in zip(matrix[i], matrix[r])]
         lead += 1
     return matrix
 def islinear(eq, fxconst):
@@ -91,7 +94,7 @@ def linear(eqlist, fxconst):
     for i in range(len(m)):
         for j in range(len(m[i])):
             m[i][j] = fraction(m[i][j])
-    #print(m)
+
     for item in m:
         if all(item2==tree_form("d_0") for item2 in item[:-1]) and item[-1] != tree_form("d_0"):
             return tree_form("s_false")

{mathai-0.4.0 → mathai-0.4.2}/mathai/simplify.py

@@ -279,6 +279,7 @@ def simplify(eq):
                         return (eq.children[1-i].children[0]**eq.children[i]).fx("log")
             if eq.name == "f_pow" and eq.children[0] == tree_form("s_e") and eq.children[1].name == "f_log":
                 return eq.children[1].children[0]
+            
         if eq.name == "f_pow" and eq.children[0] == tree_form("d_1"):
             eq = tree_form("d_1")
         if eq.name == "f_pow" and eq.children[0] == tree_form("d_0"):
@@ -286,6 +287,23 @@ def simplify(eq):
                 error = True
             else:
                 eq = tree_form("d_0")
+        
+        if eq.name == "f_mul":
+            dic = {}
+            for child in eq.children:
+                head = child
+                tail = None
+                if child.name == "f_pow":
+                    head = child.children[0]
+                    tail = child.children[1]
+                if tail is None:
+                    tail = tree_form("d_1")
+                if head not in dic.keys():
+                    dic[head] = tail
+                else:
+                    dic[head] += tail
+            if len(eq.children) > len(dic.keys()):
+                eq = product([key if dic[key] == 1 else key**dic[key] for key in dic.keys()])
         if eq.name == "f_pow" and eq.children[0].name == "f_pow" and eq.children[0].children[1] == tree_form("d_2")**-1 and eq.children[1] == tree_form("d_2"):
             eq = eq.children[0].children[0]
         if (eq.name == "f_sin" and eq.children[0].name == "f_arcsin") or (eq.name == "f_cos" and eq.children[0].name == "f_arccos") or (eq.name == "f_tan" and eq.children[0].name == "f_arctan"):
@@ -298,7 +316,11 @@ def simplify(eq):
             eq = eq.children[0].children[0]
         if eq.name == "f_abs" and eq.children[0].name[:2] == "d_":
             eq = tree_form("d_"+str(abs(int(eq.children[0].name[2:]))))
-            
+        if eq.name == "f_abs" and "v_" not in str_form(eq.children[0]):
+            if compute(eq.children[0]) > 0.00001:
+                eq = eq.children[0]
+            elif compute(eq.children[0]) < 0.00001:
+                eq = -eq.children[0]
         if eq.name == "f_pow" and  eq.children[0].name[:2] == "d_" and frac(eq.children[1]) is not None:
             f = frac(eq.children[1])
             if f.denominator != 1:

{mathai-0.4.0 → mathai-0.4.2}/mathai/trig.py

@@ -169,7 +169,12 @@ def trig4(eq, numer=True):
     if eq.name == "f_sin":
         if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
             r = len(eq.children[0].children)%2
-            a, b = eq.children[0].children[:(len(eq.children[0].children)-r)/2], eq.children[0].children[(len(eq.children[0].children)-r)/2:]
+            a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
+                   TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
+            if len(a.children)==1:
+                a=a.children[0]
+            if len(b.children)==1:
+                b=b.children[0]
             return a.fx("sin")*b.fx("cos") + a.fx("cos")*b.fx("sin")
         if eq.children[0].name == "f_arccos":
             a = eq.children[0].children[0]
@@ -189,7 +194,12 @@ def trig4(eq, numer=True):
     if eq.name == "f_cos":
         if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
             r = len(eq.children[0].children)%2
-            a, b = eq.children[0].children[:(len(eq.children[0].children)-r)/2], eq.children[0].children[(len(eq.children[0].children)-r)/2:]
+            a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
+                   TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
+            if len(a.children)==1:
+                a=a.children[0]
+            if len(b.children)==1:
+                b=b.children[0]
             return a.fx("cos")*b.fx("cos") - a.fx("sin")*b.fx("sin")
         if eq.children[0].name == "f_arcsin":
             a = eq.children[0].children[0]
@@ -199,16 +209,37 @@ def trig4(eq, numer=True):
             return tree_form("d_1")/(1+a**2)**(tree_form("d_2")**-1)
     
     return TreeNode(eq.name, [trig4(child, False) if not numer or (eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) < 0) else trig4(child, True) for child in eq.children])
+
 def trig2(eq):
     if eq.name == "f_add":
         for item in itertools.combinations(range(len(eq.children)), 2):
-            if all(eq.children[item2].name == "f_sin" for item2 in item):
-                a, b = eq.children[item[0]].children[0], eq.children[item[1]].children[0]
-                rest = [item2 for index, item2 in enumerate(eq.children) if index not in item]
-                if len(rest)==0:
-                    rest = tree_form("d_0")
+            child1, child2 = eq.children[item[0]], eq.children[item[1]]
+
+            # Check if both are sin or cos
+            if child1.name in ["f_sin", "f_cos"] and child2.name in ["f_sin", "f_cos"]:
+                a, b = child1.children[0], child2.children[0]
+                
+                # Compute the rest of the sum
+                rest = [eq.children[i] for i in range(len(eq.children)) if i not in item]
+                if len(rest) == 0:
+                    rest_tree = tree_form("d_0")
+                else:
+                    rest_tree = summation(rest)
+
+                # Now handle the sin/cos combination formula
+                if child1.name == "f_sin" and child2.name == "f_sin":
+                    # sin A + sin B = 2 sin((A+B)/2) cos((A-B)/2)
+                    two = tree_form("d_2")
+                    combined = two * ((a + b) / two).fx("sin") * ((a - b) / two).fx("cos")
+                elif child1.name == "f_cos" and child2.name == "f_cos":
+                    # cos A + cos B = 2 cos((A+B)/2) cos((A-B)/2)
+                    two = tree_form("d_2")
+                    combined = two * ((a + b) / two).fx("cos") * ((a - b) / two).fx("cos")
                 else:
-                    rest = summation(rest)
-                two = tree_form("d_2")
-                return rest + two*((a+b)/two).fx("sin")*((a-b)/two).fx("cos")
+                    # sin A + cos B = sin A + cos B (leave unchanged, or implement formula if desired)
+                    continue  # skip for now, keep original
+
+                return rest_tree + combined
+
+    # Recurse for other nodes
     return TreeNode(eq.name, [trig2(child) for child in eq.children])

{mathai-0.4.0 → mathai-0.4.2}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.0
+Version: 0.4.2
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Author: educated indians are having a low iq and are good for nothing

{mathai-0.4.0 → mathai-0.4.2}/mathai.egg-info/SOURCES.txt

@@ -15,7 +15,6 @@ mathai/linear.py
 mathai/logic.py
 mathai/parser.py
 mathai/printeq.py
-mathai/search.py
 mathai/simplify.py
 mathai/structure.py
 mathai/tool.py

{mathai-0.4.0 → mathai-0.4.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="0.4.0",
+    version="0.4.2",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

mathai-0.4.0/mathai/search.py

@@ -1,117 +0,0 @@
-from mathai import *
-import copy
-from concurrent.futures import ThreadPoolExecutor, TimeoutError
-
-def dfs_simplify(equation, functions, true_expr, false_expr,
-                 max_timeout=25, max_small=4,
-                 base_timeout=1, time_per_char=0.1, timeout_increase=0.5):
-    """
-    Perform DFS simplification on a given equation using provided functions.
-
-    Args:
-        equation: The starting expression (TreeNode or parsed equation)
-        functions: List of simplification functions
-        true_expr: Expression representing True (immediate termination)
-        false_expr: Expression representing False (immediate termination)
-        max_timeout: Maximum timeout allowed for any function
-        max_small: Number of smallest expressions to track
-        base_timeout: Base timeout in seconds
-        time_per_char: Additional timeout per character of expression
-        timeout_increase: Factor to increase timeout for consecutive timeouts
-
-    Returns:
-        tuple(found_boolean, boolean_path, smallest_expressions)
-    """
-    original_eq = simplify(equation)
-    smallest_four = []
-
-    stack = [(copy.deepcopy(original_eq), [copy.deepcopy(original_eq)])]
-    visited = set()
-
-    found_boolean = False
-    boolean_path = None
-    boolean_expr = None
-
-    executor = ThreadPoolExecutor(max_workers=3)
-    consecutive_timeouts = 0
-
-    while stack and not found_boolean:
-        current_eq, path = stack.pop()
-        expr_str = str(current_eq)
-
-        if expr_str in visited:
-            continue
-        visited.add(expr_str)
-
-        # Thinking message
-        printeq(current_eq)
-
-        # Immediate termination using predicate functions
-        if true_expr(current_eq):
-            found_boolean = True
-            boolean_path = path
-            boolean_expr = current_eq
-            break
-        if false_expr(current_eq):
-            found_boolean = True
-            boolean_path = path
-            boolean_expr = current_eq
-            break
-
-
-        # Insert into smallest_four if qualifies
-        inserted = False
-        for j in range(len(smallest_four)):
-            if len(expr_str) < len(str(smallest_four[j][0])):
-                smallest_four.insert(j, (copy.deepcopy(current_eq), copy.deepcopy(path)))
-                inserted = True
-                break
-        if not inserted and len(smallest_four) < max_small:
-            smallest_four.append((copy.deepcopy(current_eq), copy.deepcopy(path)))
-        if len(smallest_four) > max_small:
-            smallest_four = smallest_four[:max_small]
-
-        # Calculate adaptive timeout with cap
-        timeout = (base_timeout + time_per_char * len(expr_str)) * (1 + timeout_increase * consecutive_timeouts)
-        if timeout > max_timeout:
-            timeout = max_timeout
-
-        # Try functions that reduce length first
-        reduced_any = False
-        for fx in functions:
-            print(f"[Thinking] Executing {fx.__name__} on current expression (timeout={timeout:.2f}s):")
-            printeq(current_eq)
-            future = executor.submit(fx, current_eq)
-            try:
-                new_expr = future.result(timeout=timeout)
-                new_expr_str = str(new_expr)
-                if len(new_expr_str) <= len(expr_str) and new_expr_str != expr_str:
-                    reduced_any = True
-                    stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-                consecutive_timeouts = 0  # reset after success
-            except TimeoutError:
-                print(f"[Thinking] {fx.__name__} timed out, skipping.")
-                consecutive_timeouts += 1
-                continue
-
-        # If no reducing function worked, try growing functions
-        if not reduced_any:
-            for fx in functions:
-                print(f"[Thinking] Trying growing {fx.__name__} on current expression (timeout={timeout:.2f}s):")
-                printeq(current_eq)
-                future = executor.submit(fx, current_eq)
-                try:
-                    new_expr = future.result(timeout=timeout)
-                    new_expr_str = str(new_expr)
-                    if new_expr_str != expr_str:
-                        stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-                        consecutive_timeouts = 0
-                        break  # only take one growing function
-                except TimeoutError:
-                    print(f"[Thinking] {fx.__name__} (growing) timed out, skipping.")
-                    consecutive_timeouts += 1
-                    continue
-
-    executor.shutdown(wait=True)
-
-    return found_boolean, boolean_path, smallest_four