mathai 0.5.4__py3-none-any.whl → 0.5.5__py3-none-any.whl

mathai/__init__.py

@@ -9,7 +9,7 @@ from .parser import parse
 
 from .printeq import printeq, printeq_log, printeq_str
 
-from .simplify import solve, simplify, solve2
+from .simplify import simplify
 
 from .integrate import ref as integrate_save
 from .integrate import integrate_subs_main as integrate_subs
@@ -24,7 +24,7 @@ from .integrate import integrate_formula
 from .diff import diff
 
 from .factor import factor as factor1
-from .factor import factor2
+from .factor import factor2, factor3
 from .factor import rationalize_sqrt as rationalize
 from .factor import merge_sqrt
 from .factor import factorconst as factor0
@@ -35,7 +35,7 @@ from .inverse import inverse
 
 from .trig import trig0, trig1, trig2, trig3, trig4
 
-from .logic import logic0, logic1, logic2, logic3
+from .logic import logic0, logic1, logic2, logic3, logic_n
 
 from .apart import apart, apart2
 

mathai/base.py

@@ -126,6 +126,44 @@ def remove_duplicates_custom(lst, rcustom):
         if not any(rcustom(item, x) for x in result):
             result.append(item)
     return result
+def frac_to_tree(f):
+    if isinstance(f, int):
+        f = Fraction(f)
+    if f.numerator == 0:
+        return tree_form("d_0")
+    if f.numerator == 1:
+        if f.denominator == 1:
+            return tree_form("d_1")
+        return tree_form("d_"+str(f.denominator))**tree_form("d_-1")
+    if f.denominator == 1:
+        return tree_form("d_"+str(f.numerator))
+    else:
+        return tree_form("d_"+str(f.numerator))/tree_form("d_"+str(f.denominator))
+def perfect_root(n, r):
+    if r <= 0 or (n < 0 and r % 2 == 0):
+        return False, None
+
+    lo = 0
+    hi = n if n > 1 else 1
+
+    while lo <= hi:
+        mid = lo + (hi - lo) // 2
+        pow_val = 1
+
+        for _ in range(r):
+            pow_val *= mid
+            if pow_val > n:
+                break
+
+        if pow_val == n:
+            return True, mid
+        elif pow_val < n:
+            lo = mid + 1
+        else:
+            hi = mid - 1
+
+    return False, None
+
 def frac(eq):
     if eq.name[:2] == "d_":
         return Fraction(int(eq.name[2:]))
@@ -154,12 +192,17 @@ def frac(eq):
     if eq.name == "f_pow":
         a = frac(eq.children[0])
         b = frac(eq.children[1])
-        if isinstance(a, Fraction) and isinstance(b, Fraction) and b.denominator==1:
-            if a == 0 and b <= 0:
-                return None
-            return a**b
-        else:
+        if a is None or b is None:
+            return None
+        if a == 0 and b <= 0:
             return None
+        if b.denominator == 1:
+            return a ** b.numerator
+        found_c, c = perfect_root(a.numerator, b.denominator)
+        found_d, d = perfect_root(a.denominator, b.denominator)
+        if found_c and found_d:
+            return Fraction(c,d) ** b.numerator
+        return None
     return None
 def factor_generation(eq):
     output = []
@@ -168,11 +211,6 @@ def factor_generation(eq):
     if eq.name == "f_mul":
         for child in eq.children:
             if child.name == "f_pow":
-                '''
-                if child.children[0].name[:2] == "s_":
-                    output.append(child)
-                    continue
-                '''
                 if child.children[1].name[:2] != "d_":
                     output.append(child)
                     continue
@@ -180,7 +218,10 @@ def factor_generation(eq):
                     n = int(child.children[1].name[2:])
                     if n < 0:
                         for i in range(-n):
-                            output.append(child.children[0]**-1)
+                            out = factor_generation(child.children[0])
+                            out = [x**-1 for x in out]
+                            output += out
+                            #output.append(child.children[0]**-1)
                     else:
                         for i in range(n):
                             output.append(child.children[0])
@@ -247,14 +288,19 @@ def num_dem(equation):
     num = tree_form("d_1")
     den = tree_form("d_1")
     for item in factor_generation(equation):
-        
-        t = item
-        if t.name == "f_pow" and "v_" not in str_form(t.children[1]) and compute(t.children[1]) < 0:
-            
-            den = den*item
+        if item.name == "f_pow":
+            c = frac(item.children[1])
+            if c is not None and c < 0:
+                t = frac_to_tree(-c)
+                if t == tree_form("d_1"):
+                    den = den * item.children[0]
+                else:
+                    den = den * item.children[0]**t
+            else:
+                den = den * item
         else:
             num = num*item
-    return [num, tree_form("d_1")/den]
+    return num, den
 
 def summation(lst):
     if len(lst) == 0:

mathai/diff.py

@@ -1,9 +1,9 @@
-from .simplify import solve
+from .simplify import simplify
 from .base import *
 from .trig import trig0
 def diff(equation, var="v_0"):
     def diffeq(eq):
-        eq = solve(eq)
+        eq = simplify(eq)
         if "v_" not in str_form(eq):
             return tree_form("d_0")
         if eq.name == "f_add":
@@ -65,4 +65,4 @@ def diff(equation, var="v_0"):
         return TreeNode(equation.name, [helper(child, var) for child in equation.children])
     equation = diffeq(trig0(equation))
     equation = helper(equation, var)
-    return solve(equation)
+    return simplify(equation)

mathai/expand.py

@@ -1,96 +1,124 @@
 import itertools
 from .base import *
-from .simplify import solve, simplify
-
-def expand(eq):
-    if eq is None:
-        return None
-
-    stack = [(eq, 0)]  # (node, stage)
-    result_map = {}     # id(node) -> expanded TreeNode
+from .simplify import simplify
+'''
+def _expand(equation):
+    eq = equation
+    eq.children = [_expand(flatten_tree(child)) for child in eq.children]
+    if eq.name == "f_pow":
+        n = frac(eq.children[1])
+        if n is not None and n.denominator == 1 and n.numerator > 1:
+            power_children = []
+            for i in range(n.numerator):
+                power_children.append(eq.children[0])
+            return _expand(flatten_tree(TreeNode("f_mul", power_children)))
+    if eq.name == "f_mul":
+        lone_children = tree_form("d_1")
+        bracket_children = []
+        for i in range(len(eq.children)-1,-1,-1):
+            if eq.children[i].name == "f_add":
+                bracket_children.append(eq.children[i])
+            elif eq.children[i].name == "f_pow" and eq.children[i].children[0].name == "f_add":
+                n = frac(eq.children[i].children[1])
+                if n is not None and n.denominator == 1 and n.numerator > 1:
+                    for j in range(n.numerator):
+                        bracket_children.append(eq.children[i].children[0])
+                else:
+                    lone_children = lone_children * eq.children[i]
+            else:
+                lone_children = lone_children * eq.children[i]
+        lone_children = simplify(lone_children)
+        while bracket_children != []:
+            tmp = tree_form("d_0")
+            for i in range(len(bracket_children[0].children)):
+                if lone_children.name == "f_add":
+                    for j in range(len(lone_children.children)):
+                        tmp = tmp + bracket_children[0].children[i] * lone_children.children[j]
+                else:
+                    tmp = tmp + lone_children * bracket_children[0].children[i]
+            lone_children = flatten_tree(simplify(tmp))
+            bracket_children.pop(0)
+        return lone_children
+    return eq
+'''
+def _expand(equation):
+    """Iterative version of _expand without recursion."""
+    # Stack: (node, child_index, partially_processed_children)
+    stack = [(equation, 0, [])]
 
     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])
-
-                ac = []
-                addchild = []
-
-                for child in current_eq.children:
-                    tmp5 = [solve(x) for x in factor_generation(child)]
-                    ac += tmp5
-
-                tmp3 = []
-                for child in ac:
-                    tmp2 = []
+        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
+                            tmp = tmp + bc * lone_children
+                    # Simplify after each distribution
+                    lone_children = flatten_tree(simplify(tmp))
 
-                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)
+                node = lone_children
 
-                # Store expanded result
-                result_map[node_id] = current_eq
+            # === 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, []))
 
+def expand(eq):
+    return _expand(eq)

mathai/factor.py

@@ -1,12 +1,14 @@
 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 .printeq import printeq
 from collections import Counter
 def multiset_intersection(*lists):
     counters = list(map(Counter, 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
         hcf = numbers[0]
         for num in numbers[1:]:
-            hcf = math.gcd(hcf, num)
-        return hcf
+            if num < 0:
+                n = -1
+            hcf = math.gcd(hcf, abs(num))
+        return hcf*n
     def extractnum(eq):
         lst = factor_generation(eq)
         for item in lst:
@@ -226,8 +231,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
@@ -237,14 +242,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):
@@ -252,7 +270,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")):
@@ -266,17 +284,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
@@ -169,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)
@@ -187,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":
@@ -411,6 +411,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)]
@@ -426,6 +427,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()
@@ -441,15 +446,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

mathai/limit.py

@@ -1,7 +1,7 @@
 from .structure import structure
 from .base import *
 from .parser import parse
-from .simplify import simplify, solve
+from .simplify import simplify
 from .expand import expand
 from .diff import diff
 from .trig import trig0

mathai/linear.py

@@ -1,7 +1,7 @@
 from .inverse import inverse
 import itertools
 from .diff import diff
-from .simplify import simplify, solve
+from .simplify import simplify
 from .fraction import fraction
 from .expand import expand
 from .base import *

mathai/logic.py

@@ -1,6 +1,12 @@
 import itertools
 from .base import *
-
+def c(eq):
+     eq = logic1(eq)
+     eq = dowhile(eq, logic0)
+     eq = dowhile(eq, logic2)
+     return eq
+def logic_n(eq):
+     return dowhile(eq, c)
 def logic0(eq):
      if eq.children is None or len(eq.children)==0:
          return eq