mathai 0.4.8__py3-none-any.whl → 0.7.2__py3-none-any.whl

mathai/expand.py

@@ -1,96 +1,175 @@
-import itertools
 from .base import *
-from .simplify import solve, simplify
+from .simplify import simplify
+import itertools
 
-def expand(eq):
-    if eq is None:
-        return None
+def eliminate_powers(node):
+    if not node.children:
+        return node
 
-    stack = [(eq, 0)]  # (node, stage)
-    result_map = {}     # id(node) -> expanded TreeNode
+    node.children = [eliminate_powers(c) for c in node.children]
+
+    if node.name == "f_pow":
+        base, exp = node.children
+        n = frac(exp)
+
+        # Only expand positive integer powers
+        if not (n and n.denominator == 1 and n.numerator > 1):
+            return node
+
+        n = n.numerator
+
+        # ---- Multinomial expansion ----
+        if base.name == "f_add":
+            terms = []
+            for combo in itertools.product(base.children, repeat=n):
+                prod = combo[0]
+                for c in combo[1:]:
+                    prod = prod * c
+                terms.append(prod)
+            return simplify(TreeNode("f_add", terms))
+
+        # ---- Fallback: simple power ----
+        return TreeNode("f_mul", [base] * n)
+
+    return node
 
-    while stack:
-        node, stage = stack.pop()
-        node_id = id(node)
-
-        # Leaf node
-        if not node.children and stage == 0:
-            result_map[node_id] = TreeNode(node.name, [])
-            continue
-
-        if stage == 0:
-            # Stage 0: push node back for stage 1 after children
-            stack.append((node, 1))
-            # Push children to stack
-            for child in reversed(node.children):
-                if id(child) not in result_map:
-                    stack.append((child, 0))
-        else:
-            # Stage 1: all children processed
-            children_expanded = [result_map[id(child)] for child in node.children]
 
-            # Only f_mul or f_pow need special expansion
-            if node.name in ["f_mul", "f_pow"]:
-                current_eq = TreeNode(node.name, children_expanded)
 
-                if node.name == "f_pow":
-                    current_eq = TreeNode("f_pow", [current_eq])
+# =====================================================
+# Phase 2: Single distributive rewrite (DEEPEST FIRST)
+# =====================================================
 
-                ac = []
-                addchild = []
+def expand_once(node):
+    """
+    Performs exactly ONE distributive expansion.
+    Deepest-first (post-order).
+    """
 
-                for child in current_eq.children:
-                    tmp5 = [solve(x) for x in factor_generation(child)]
-                    ac += tmp5
+    # ---- recurse FIRST (this is the fix) ----
+    for i, c in enumerate(node.children):
+        new, changed = expand_once(c)
+        if changed:
+            node.children[i] = new
+            return node, True
 
-                tmp3 = []
-                for child in ac:
-                    tmp2 = []
+    # ---- now try expanding at this node ----
+    if node.name == "f_mul":
+        for i, child in enumerate(node.children):
+            if child.name == "f_add":
+                left = node.children[:i]
+                right = node.children[i+1:]
+
+                terms = []
+                for t in child.children:
+                    prod = t
+                    for r in right:
+                        prod = prod * r
+                    for l in reversed(left):
+                        prod = l * prod
+                    terms.append(prod)
+
+                return TreeNode("f_add", terms), True
+
+    return node, False
+
+def _expand2(equation):
+    """Iterative version of _expand without recursion."""
+    # Stack: (node, child_index, partially_processed_children)
+    stack = [(equation, 0, [])]
+
+    while stack:
+        node, child_index, processed_children = stack.pop()
+
+        # If all children are processed
+        if child_index >= len(node.children):
+            # Replace children with processed versions
+            node.children = processed_children
+
+            # === Handle f_pow ===
+            if node.name == "f_pow":
+                n = frac(node.children[1])
+                if n is not None and n.denominator == 1 and n.numerator > 1:
+                    # Convert power to repeated multiplication
+                    power_children = [node.children[0] for _ in range(n.numerator)]
+                    new_node = TreeNode("f_mul", power_children)
+                    # Flatten tree
+                    node = flatten_tree(new_node)
+                    # Push it back for further processing
+                    stack.append((node, 0, []))
+                    continue
+
+            # === Handle f_mul ===
+            elif node.name == "f_mul":
+                # Separate lone children and bracket children
+                lone_children = tree_form("d_1")
+                bracket_children = []
+
+                # Iterate in reverse (like original)
+                for child in reversed(node.children):
                     if child.name == "f_add":
-                        if child.children != []:
-                            tmp2.extend(child.children)
+                        bracket_children.append(child)
+                    elif child.name == "f_pow" and child.children[0].name == "f_add":
+                        n = frac(child.children[1])
+                        if n is not None and n.denominator == 1 and n.numerator > 1:
+                            for _ in range(n.numerator):
+                                bracket_children.append(child.children[0])
                         else:
-                            tmp2 = [child]
+                            lone_children = lone_children * child
                     else:
-                        tmp3.append(child)
-                    if tmp2 != []:
-                        addchild.append(tmp2)
-
-                tmp4 = 1
-                for item in tmp3:
-                    tmp4 = tmp4 * item
-                addchild.append([tmp4])
-
-                def flatten(lst):
-                    flat_list = []
-                    for item in lst:
-                        if isinstance(item, list) and item == []:
-                            continue
-                        if isinstance(item, list):
-                            flat_list.extend(flatten(item))
+                        lone_children = lone_children * child
+
+                lone_children = simplify(lone_children)
+
+                # Distribute bracket children over lone children iteratively
+                while bracket_children:
+                    tmp = tree_form("d_0")
+                    bracket = bracket_children.pop(0)
+                    for bc in bracket.children:
+                        if lone_children.name == "f_add":
+                            for lc in lone_children.children:
+                                tmp = tmp + bc * lc
                         else:
-                            flat_list.append(item)
-                    return flat_list
-
-                if len(flatten(addchild)) > 0:
-                    add = 0
-                    for prod_items in itertools.product(*addchild):
-                        mul = 1
-                        for item2 in prod_items:
-                            mul = mul * item2
-                            mul = simplify(mul)
-                        add = add + mul
-                        add = simplify(add)
-                    current_eq = simplify(add)
-                else:
-                    current_eq = simplify(current_eq)
-
-                # Store expanded result
-                result_map[node_id] = current_eq
+                            tmp = tmp + bc * lone_children
+                    # Simplify after each distribution
+                    lone_children = flatten_tree(simplify(tmp))
+
+                node = lone_children
+
+            # === Return node to parent ===
+            if stack:
+                parent, idx, parent_children = stack.pop()
+                parent_children.append(node)
+                stack.append((parent, idx + 1, parent_children))
             else:
-                # Default: reconstruct node with children
-                result_map[node_id] = TreeNode(node.name, children_expanded)
+                # Root node fully expanded
+                return node
 
-    # Return final expanded eq
-    return result_map[id(eq)]
+        else:
+            # Push current node back for next child
+            stack.append((node, child_index, processed_children))
+            # Push the child to process next
+            child = flatten_tree(node.children[child_index])
+            stack.append((child, 0, []))
 
+# =====================================================
+# Phase 3: Global fixed-point driver
+# =====================================================
+
+def expand(eq):
+    orig = TreeNode.matmul
+    if TreeNode.matmul is None:
+        return _expand2(eq)
+    eq = simplify(eq)
+    if TreeNode.matmul is not None:
+        TreeNode.matmul = True
+        eq = tree_form(str_form(eq).replace("f_wmul", "f_mul"))
+        eq = flatten_tree(eq)
+    eq = eliminate_powers(eq)
+    while True:        
+        eq = flatten_tree(eq)        
+        eq, changed = expand_once(eq)
+        if not changed:
+            break
+    eq =simplify(eq)
+    TreeNode.matmul = orig
+    return eq

mathai/factor.py

@@ -1,11 +1,13 @@
 import itertools
+from .trig import trig0
 from .parser import parse
 from .structure import transform_formula
 from .base import *
-from .simplify import simplify,solve
+from .simplify import simplify
 from .expand import expand
 import math
 from .tool import poly
+from .fraction import fraction
 
 from collections import Counter
 def multiset_intersection(*lists):
@@ -31,8 +33,8 @@ def term_common2(eq):
     return product(s)*summation([product(subtract_sublist(factor_generation(child), s)) for child in eq.children])
 def term_common(eq):
     if eq.name == "f_add":
-        return solve(term_common2(eq))
-    return solve(product([term_common2(item) for item in factor_generation(eq)]))
+        return simplify(term_common2(eq))
+    return simplify(product([term_common2(item) for item in factor_generation(eq)]))
 def take_common(eq):
     if eq.name == "f_add":
         eq = term_common(eq)
@@ -42,7 +44,7 @@ def take_common(eq):
                     eq2 = summation([item2 for index, item2 in enumerate(eq.children) if index in item])
                     eq2 = term_common(eq2)
                     if eq2.name == "f_mul":
-                        return take_common(solve(summation([item2 for index, item2 in enumerate(eq.children) if index not in item]) + eq2))
+                        return take_common(simplify(summation([item2 for index, item2 in enumerate(eq.children) if index not in item]) + eq2))
                 break
         return eq
     return term_common(eq)
@@ -54,10 +56,13 @@ def _factorconst(eq):
     def hcf_list(numbers):
         if not numbers:
             return None  # empty list
+        n = 1
+        if math.prod(numbers) < 0:
+            n = -1
         hcf = numbers[0]
         for num in numbers[1:]:
-            hcf = math.gcd(hcf, num)
-        return hcf
+            hcf = math.gcd(hcf, abs(num))
+        return hcf*n
     def extractnum(eq):
         lst = factor_generation(eq)
         for item in lst:
@@ -169,9 +174,11 @@ def factor_quar_formula_init():
     return [formula_list, var, expr]
 
 formula_gen9 = factor_quar_formula_init()
+
 def factor_helper(equation, complexnum, power=2):
     global formula_gen9
-    
+    if equation.name in ["f_or", "f_and", "f_not", "f_eq", "f_gt", "f_lt", "f_ge", "f_le"]:
+        return TreeNode(equation.name, [factor_helper(child, complexnum, power) for child in equation.children])
     maxnum=1
     alloclst = []
     for i in range(0,26):
@@ -225,8 +232,8 @@ def factor_helper(equation, complexnum, power=2):
                             a, b, c = lst
                             x1 = (-b+(b**2 - 4*a*c)**(tree_form("d_2")**-1))/(2*a)
                             x2 = (-b-(b**2 - 4*a*c)**(tree_form("d_2")**-1))/(2*a)
-                            x1 = simplify(x1)
-                            x2 = simplify(x2)
+                            x1 = expand(simplify(x1))
+                            x2 = expand(simplify(x2))
                             eq2 = a*(tree_form(r)-x1)*(tree_form(r)-x2)
                             if not complexnum and (contain(x1, tree_form("s_i")) or contain(x2, tree_form("s_i"))):
                                 success = False
@@ -236,14 +243,27 @@ def factor_helper(equation, complexnum, power=2):
                             p = C-(B**2)/3
                             q = 2*B**3/27-B*C/3+D
                             t = q**2/4+ p**3/27
-                            u = (-q/2+t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
-                            v = (-q/2-t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
-                            y1 = u+v
-                            three = 3**(tree_form("d_2")**-1)
-                            y2 = -(u+v)/2+tree_form("s_i")*three*(u-v)/2
-                            y3 = -(u+v)/2-tree_form("s_i")*three*(u-v)/2
+
+                            if compute(t) > 0:
+                                u = (-q/2+t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
+                                v = (-q/2-t**(tree_form("d_2")**-1))**(tree_form("d_3")**-1)
+                                y1 = u+v
+                                three = 3**(tree_form("d_2")**-1)
+                                y2 = -(u+v)/2+tree_form("s_i")*three*(u-v)/2
+                                y3 = -(u+v)/2-tree_form("s_i")*three*(u-v)/2
+                                
+                            else:
+                                ar = 2*(-p/3)**(tree_form("d_2")**-1)
+                                phi = ((3*q/(2*p))*(-3/p)**(tree_form("d_2")**-1)).fx("arccos")
+                                y1 = ar*(phi/3).fx("cos")
+                                y2 = ar*((phi+2*tree_form("s_pi"))/3).fx("cos")
+                                y3 = ar*((phi+4*tree_form("s_pi"))/3).fx("cos")
+                                
                             x1,x2,x3 = y1-B/3 , y2-B/3, y3-B/3
-                            x1,x2, x3 = simplify(x1), simplify(x2), simplify(x3)
+                            x1 = simplify(trig0(simplify(x1)))
+                            x2 = simplify(trig0(simplify(x2)))
+                            x3 = simplify(trig0(simplify(x3)))
+                            
                             out2 = None
                             if not complexnum:
                                 for item in itertools.combinations([x1,x2,x3],2):
@@ -251,7 +271,7 @@ def factor_helper(equation, complexnum, power=2):
                                         out2 = (tree_form(r)-item[0])*(tree_form(r)-item[1])
                                         break
                             if out2 is not None:
-                                out2 = simplify(expand(simplify(out2)))
+                                out2 = simplify(fraction(expand(simplify(out2))))
                                 out3 = None
                                 for item in [x1, x2, x3]:
                                     if not contain(item,tree_form("s_i")):
@@ -265,17 +285,21 @@ def factor_helper(equation, complexnum, power=2):
                             equation = fx(eq2)
                             break
     
-    if power == 4:
+    if False and power == 4:
         
         out = transform_formula(helper(equation), "v_0", formula_gen9[0], formula_gen9[1], formula_gen9[2])
     
     if out is not None:
-        out = simplify(solve(out))
+        out = simplify(out)
     if out is not None and (complexnum or (not complexnum and not contain(out, tree_form("s_i")))):
         return out
     
     return TreeNode(equation.name, [factor_helper(child, complexnum, power) for child in equation.children])
 def factor(equation):
-    return solve(take_common2(simplify(equation)))
+    return simplify(take_common2(simplify(equation)))
+
 def factor2(equation, complexnum=False):
-    return solve(factor_helper(solve(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3)), complexnum, 4))
+    return simplify(factor_helper(simplify(equation), complexnum, 2))
+
+def factor3(equation, complexnum=False):
+    return simplify(factor_helper(simplify(factor_helper(simplify(equation), complexnum, 2)), complexnum, 3))

mathai/fraction.py

@@ -1,5 +1,5 @@
 from .base import *
-from .simplify import solve, simplify
+from .simplify import simplify
 from .expand import expand
 
 def fraction(eq):
@@ -100,4 +100,4 @@ def fraction(eq):
         result_map[node] = TreeNode(node.name, children_processed)
 
     # Final return
-    return solve(result_map[eq])
+    return simplify(result_map[eq])

mathai/integrate.py

@@ -3,7 +3,7 @@ from .parser import parse
 import itertools
 from .diff import diff
 from .fraction import fraction
-from .simplify import solve, simplify
+from .simplify import simplify
 from .expand import expand
 from .base import *
 from .printeq import printeq_str
@@ -79,8 +79,10 @@ def subs_heuristic(eq, var):
 try_index = []
 try_lst = []
 def ref(eq):
+    '''
     if eq.name in ["f_try", "f_ref"]:
         return eq
+    '''
     if eq.name  == "f_integrate":
         return TreeNode("f_try", [eq.fx("ref"), eq])
     return TreeNode(eq.name, [ref(child) for child in eq.children])
@@ -98,12 +100,12 @@ def _solve_integrate(eq):
     if eq.name == "f_ref":
         return eq
     if eq.name == "f_subs":
-        if "f_integrate" not in str_form(eq.children[0]):
+        if all(item not in str_form(eq.children[0]) for item in ["f_integrate", "f_subs", "f_try"]):
             return replace(eq.children[0], eq.children[1], eq.children[2])
     
     if eq.name == "f_try":
         for child in eq.children:
-            if "f_integrate" not in str_form(child):
+            if all(item not in str_form(child) for item in ["f_integrate", "f_subs", "f_try"]):
                 return child
     return TreeNode(eq.name, [_solve_integrate(child) for child in eq.children])
 def handle_try(eq):
@@ -131,6 +133,7 @@ def inteq(eq):
                 break
         if eq2 is None:
             return eq
+        printeq(eq)
         for child in eq.children:
             if child.name == "f_ref":
                 output.append(child)
@@ -144,6 +147,8 @@ def inteq(eq):
                         output.append(out)
                 else:
                     output.append(child)
+        printeq(TreeNode("f_try", output))
+        print()
         return TreeNode("f_try", output)
     else:
         return TreeNode(eq.name, [inteq(child) for child in eq.children])
@@ -164,7 +169,7 @@ def integrate_subs(equation, term, v1, v2):
     orig = equation.copy_tree()
     none = TreeNode("f_integrate",[orig, tree_form(v1)])
     origv2 = copy.deepcopy(v2)
-    equation = solve(equation)
+    equation = simplify(equation)
     eq = equation
     termeq = term
     t = inverse(copy.deepcopy(termeq), v1)
@@ -182,13 +187,13 @@ def integrate_subs(equation, term, v1, v2):
                
         eq2 = replace(diff(g, v1), tree_form(v1), t)
         equation = eq/eq2
-        equation = solve(equation)
+        equation = simplify(equation)
         
     if v1 in str_form(equation):
         
         return none
 
-    return TreeNode("f_subs", [TreeNode("f_integrate", [simplify(equation), tree_form(origv2)]),tree_form(origv2) ,g])
+    return dowhile(TreeNode("f_subs", [TreeNode("f_integrate", [simplify(equation), tree_form(origv2)]),tree_form(origv2) ,g]), trig0)
 
 def integrate_subs_main(equation):
     if equation.name == "f_ref":
@@ -330,13 +335,20 @@ def byparts(eq):
         lst = factor_generation(eq)
         if len(lst) == 3 and len(list(set(lst))) == 1:
             lst = [(lst[0]**2).copy_tree(), lst[0].copy_tree()]
+        if len(lst) == 3 and len(list(set(lst))) == 2:
+            lst2 = list(set(lst))
+            a, b = lst2
+            a = a**lst.count(a)
+            b = b**lst.count(b)
+            lst = [a.copy_tree(), b.copy_tree()]
         if len(lst) == 1:
             lst += [tree_form("d_1")]
         if len(lst) == 2:
             for i in range(2):
                 
                 f, g = [lst[i], lst[1-i]]
-                
+                if contain(f, tree_form("s_e")):
+                    continue
                 out1 = TreeNode("f_integrate", [g.copy_tree(), wrt])
 
                 
@@ -368,7 +380,6 @@ def integration_formula_init():
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A"), parse("1")], [parse("B"), parse("0")]]
     return [formula_list, var, expr]
-formula_gen = integration_formula_init()
 def integration_formula_trig():
     var = "x"
     formula_list = [(f"(A+B*sin({var})+C*cos({var}))/(D+E*sin({var})+F*cos({var}))", f"((B*E+C*F)/(E^2+F^2))*{var}+((C*E-B*F)/(E^2+F^2))*log(D+E*sin({var})+F*cos({var}))")]
@@ -377,8 +388,12 @@ def integration_formula_trig():
             [parse("C"), parse("0"), parse("1")], [parse("D"), parse("0"), parse("1")],\
             [parse("E"), parse("0"), parse("1")], [parse("F"), parse("0"), parse("1")]]
     return [formula_list, var, expr]
+
+
+formula_gen = integration_formula_init()
 formula_gen4 = integration_formula_trig()
 
+
 def integration_formula_ex():
     var = "x"
     formula_list = [
@@ -399,6 +414,7 @@ def rm_const(equation):
     if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
         wrt = eq2.children[1]
+        
         lst = factor_generation(equation)
         
         lst_const = [item for item in lst if not contain(item, wrt)]
@@ -414,6 +430,10 @@ def rm_const(equation):
         equation = eq2
     return TreeNode(equation.name, [rm_const(child)  for child in equation.children])
 
+def shorten(eq):
+    if eq.name.startswith("d_"):
+        return tree_form("d_0")
+    return TreeNode(eq.name, [shorten(child) for child in eq.children])
 def integrate_formula(equation):
     if equation.name == "f_ref":
         return equation.copy_tree()
@@ -429,15 +449,14 @@ def integrate_formula(equation):
         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:
-                
-                return out
-        if "f_cos" in expr_str and contain(integrand, tree_form("s_e")):
-            out = transform_formula(integrand, wrt.name, formula_gen11[0], formula_gen11[1], formula_gen11[2])
-            if out is not None:
-                
-                return out
+        expr_str = str_form(shorten(integrand))
+        if len(expr_str) < 30:
+            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:
+                    return out
+            if "f_cos" in expr_str and contain(integrand, tree_form("s_e")):
+                out = transform_formula(integrand, wrt.name, formula_gen11[0], formula_gen11[1], formula_gen11[2])
+                if out is not None:
+                    return out
     return TreeNode(eq2.name, [integrate_formula(child) for child in eq2.children])

mathai/inverse.py

@@ -1,5 +1,5 @@
 from .base import *
-from .simplify import solve
+from .simplify import simplify
 from .expand import expand
 def inverse(rhs,term, sign=None):
     term = tree_form(term)
@@ -9,7 +9,7 @@ def inverse(rhs,term, sign=None):
     while not rhs==term:
         if rhs.name == "f_add":
             if all(term in factor_generation(child) for child in rhs.children):
-                newrhs = solve(expand(rhs*term**-1))
+                newrhs = simplify(expand(rhs*term**-1))
                 if not contain(newrhs, term):
                     rhs = term * newrhs
             else:
@@ -61,5 +61,5 @@ def inverse(rhs,term, sign=None):
         if count == 0:
             return None
     if sign is None:
-        return solve(lhs)
-    return solve(lhs), sign
+        return simplify(lhs)
+    return simplify(lhs), sign