mathai 0.7.8__py3-none-any.whl → 0.8.0__py3-none-any.whl

mathai/expand.py

@@ -3,21 +3,12 @@ from .simplify import simplify
 import itertools
 
 def expand_nc(expr, label="f_mul"):
-    """
-    Expand expression where:
-      - f_add is commutative
-      - label (@) is NON-commutative
-    """
-    # --- base cases ---
+
     if expr.name not in {"f_add", label, "f_pow"}:
         return expr
 
-    # --- expand children first ---
     expr.children = [expand_nc(c, label) for c in expr.children]
 
-    # ==========================================================
-    # POWER: (A + B)^n  only if n is positive integer
-    # ==========================================================
     if expr.name == "f_pow":
         base, exp = expr.children
         n = frac(exp)
@@ -26,9 +17,6 @@ def expand_nc(expr, label="f_mul"):
             return expand_nc(TreeNode(label, factors), label)
         return expr
 
-    # ==========================================================
-    # ADDITION (commutative)
-    # ==========================================================
     if expr.name == "f_add":
         out = []
         for c in expr.children:
@@ -38,20 +26,15 @@ def expand_nc(expr, label="f_mul"):
                 out.append(c)
         return TreeNode("f_add", out)
 
-    # ==========================================================
-    # NON-COMMUTATIVE MULTIPLICATION (@)
-    # ==========================================================
     if expr.name == label:
         factors = []
 
-        # flatten only (NO reordering)
         for c in expr.children:
             if c.name == label:
                 factors.extend(c.children)
             else:
                 factors.append(c)
 
-        # find first additive factor
         for i, f in enumerate(factors):
             if f.name == "f_add":
                 left  = factors[:i]
@@ -66,13 +49,12 @@ def expand_nc(expr, label="f_mul"):
 
                 return TreeNode("f_add", terms)
 
-        # no addition inside → return as-is
         return TreeNode(label, factors)
 
-
 def expand2(eq, over="*"):
     over = {"@": "f_wmul", ".":"f_dot", "*":"f_mul"}[over]
     return expand_nc(eq, over)
 def expand(eq, over="*"):
     eq = expand2(eq, over)
     return TreeNode(eq.name, [expand(child, over) for child in eq.children])
+

mathai/fraction.py

@@ -2,102 +2,86 @@ from .base import *
 from .simplify import simplify
 from .expand import expand
 
-def fraction(eq):
-    stack = [(eq, None)]  # (current_node, parent_processed_children)
-    result_map = {}  # Map original nodes to their processed TreeNode
-
-    while stack:
-        node, parent_info = stack.pop()
-
-        # If node already processed, continue
-        if node in result_map:
-            continue
-
-        # Base case: leaf node
-        if not node.children:
-            result_map[node] = TreeNode(node.name, [])
-            continue
-
-        # Check if all children are processed
-        all_children_done = all(child in result_map for child in node.children)
-        if not all_children_done:
-            # Push current node back to stack after children
-            stack.append((node, parent_info))
-            for child in reversed(node.children):
-                if child not in result_map:
-                    stack.append((child, (node, node.children)))
-            continue
-
-        # Now all children are processed, handle this node
-        if node.name == "f_eq":
-            left = result_map[node.children[0]]
-            right = result_map[node.children[1]]
-            result_map[node] = TreeNode("f_eq", [left, right])
-            continue
-
-        elif node.name == "f_add":
-            con = []
-            for child in node.children:
-                child_processed = result_map[child]
-                if child_processed.name == "f_pow" and child_processed.children[1].name[:2] == "d_" and int(child_processed.children[1].name[2:]) < 0:
-                    den = []
-                    n = int(child_processed.children[1].name[2:])
-                    if n == -1:
-                        den.append(child_processed.children[0])
-                    else:
-                        den.append(TreeNode("f_pow", [child_processed.children[0], tree_form("d_" + str(-n))]))
-                    con.append([[], den])
-                elif child_processed.name == "f_mul":
-                    num = []
-                    den = []
-                    for child2 in child_processed.children:
-                        if child2.name == "f_pow" and child2.children[1].name[:2] == "d_" and int(child2.children[1].name[2:]) < 0:
-                            n = int(child2.children[1].name[2:])
-                            if n == -1:
-                                den.append(child2.children[0])
-                            else:
-                                den.append(TreeNode("f_pow", [child2.children[0], tree_form("d_" + str(-n))]))
-                        else:
-                            num.append(child2)
-                    con.append([num, den])
-                else:
-                    con.append([[child_processed], []])
-
-            if len(con) > 1 and any(x[1] != [] for x in con):
-                # Construct numerator
-                a_children = []
-                for i in range(len(con)):
-                    b_children = con[i][0].copy()
-                    for j in range(len(con)):
-                        if i == j:
-                            continue
-                        b_children += con[j][1]
-                    if len(b_children) == 0:
-                        b_children = [tree_form("d_1")]
-                    elif len(b_children) == 1:
-                        b_children = b_children
+def fraction(expr):
+    if expr is None:
+        return None
+
+    expr = simplify(expr)
+
+    if expr.children == []:
+        return expr
+
+    children = [fraction(c) for c in expr.children]
+
+    if expr.name == "f_add":
+        terms = []
+
+        for c in children:
+
+            if c.name == "f_mul":
+                num = []
+                den = []
+                for f in c.children:
+                    if (
+                        f.name == "f_pow"
+                        and f.children[1].name.startswith("d_")
+                        and int(f.children[1].name[2:]) < 0
+                    ):
+                        n = int(f.children[1].name[2:])
+                        den.append(
+                            f.children[0]
+                            if n == -1
+                            else TreeNode("f_pow", [f.children[0], tree_form(f"d_{-n}")])
+                        )
                     else:
-                        b_children = [TreeNode("f_mul", b_children)]
-                    a_children += b_children if isinstance(b_children, list) else [b_children]
-
-                a = TreeNode("f_add", a_children)
-
-                # Construct denominator
-                c_children = []
-                for i in range(len(con)):
-                    c_children += con[i][1]
-                if len(c_children) == 1:
-                    c = c_children[0]
-                else:
-                    c = TreeNode("f_mul", c_children)
-                c = TreeNode("f_pow", [c, tree_form("d_-1")])
-
-                result_map[node] = TreeNode("f_mul", [simplify(expand(simplify(a))), c])
-                continue
-
-        # Default: just reconstruct node
-        children_processed = [result_map[child] for child in node.children]
-        result_map[node] = TreeNode(node.name, children_processed)
-
-    # Final return
-    return simplify(result_map[eq])
+                        num.append(f)
+                terms.append((num, den))
+
+            elif (
+                c.name == "f_pow"
+                and c.children[1].name.startswith("d_")
+                and int(c.children[1].name[2:]) < 0
+            ):
+                n = int(c.children[1].name[2:])
+                terms.append(([], [
+                    c.children[0]
+                    if n == -1
+                    else TreeNode("f_pow", [c.children[0], tree_form(f"d_{-n}")])
+                ]))
+
+            else:
+                terms.append(([c], []))
+
+        if not any(den for _, den in terms):
+            return TreeNode("f_add", children)
+
+        num_terms = []
+        for i, (num_i, _) in enumerate(terms):
+            acc = list(num_i)
+            for j, (_, den_j) in enumerate(terms):
+                if i != j:
+                    acc += den_j
+            if not acc:
+                acc = [tree_form("d_1")]
+            num_terms.append(
+                acc[0] if len(acc) == 1 else TreeNode("f_mul", acc)
+            )
+
+        numerator = TreeNode("f_add", num_terms)
+
+        den_all = []
+        for _, den in terms:
+            den_all += den
+
+        denom = den_all[0] if len(den_all) == 1 else TreeNode("f_mul", den_all)
+        denom = TreeNode("f_pow", [denom, tree_form("d_-1")])
+
+        return simplify(
+            TreeNode(
+                "f_mul",
+                [simplify(expand(numerator)), denom],
+            )
+        )
+
+    return TreeNode(expr.name, children)
+

mathai/integrate.py

@@ -97,6 +97,8 @@ def place_try2(eq):
         return eq.children[try_lst.pop(0)]
     return TreeNode(eq.name, [place_try2(child) for child in eq.children]) 
 def _solve_integrate(eq):
+    if eq is None:
+        return None
     if eq.name == "f_ref":
         return eq
     if eq.name == "f_subs":
@@ -153,6 +155,8 @@ def inteq(eq):
     else:
         return TreeNode(eq.name, [inteq(child) for child in eq.children])
 def rm(eq):
+    if eq is None:
+        return None
     if eq.name == "f_try":
         eq = TreeNode(eq.name, list(set(eq.children)))
     return TreeNode(eq.name, [rm(child) for child in eq.children if child is not None])
@@ -161,6 +165,8 @@ def solve_integrate(eq):
     eq2 = dowhile(eq, _solve_integrate)
     #eq2 = dowhile(eq2, handle_try)
     eq2 = rm(eq2)
+    if eq2 is None:
+        return None
     if eq2.name == "f_try":
         eq2.children = list(set(eq2.children))
     return eq2
@@ -409,8 +415,8 @@ def integration_formula_ex():
 
 formula_gen11 = integration_formula_ex()
 def rm_const(equation):
-    if equation.name == "f_ref":
-        return equation
+    if equation is None:
+        return None
     eq2 = equation
     if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
@@ -436,8 +442,8 @@ def shorten(eq):
         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()
+    if equation is None:
+        return None
     eq2 = equation.copy_tree()
     if eq2.name == "f_integrate":
         integrand = eq2.children[0]

mathai/linear.py

@@ -39,11 +39,10 @@ def islinear(eq, fxconst):
     return False
 def linear(eqlist, fxconst):
     orig = [item.copy_tree() for item in eqlist]
-    #eqlist = [eq for eq in eqlist if fxconst(eq)]
-    
+
     if eqlist == [] or not all(islinear(eq, fxconst) for eq in eqlist):
         return None
-        #return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in orig])
+
     vl = []
     def varlist(eq, fxconst):
         nonlocal vl
@@ -54,7 +53,7 @@ def linear(eqlist, fxconst):
     for eq in eqlist:
         varlist(eq, fxconst)
     vl = list(set(vl))
-    
+
     if len(vl) > len(eqlist):
         return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
     m = []
@@ -71,11 +70,11 @@ def linear(eqlist, fxconst):
             m[i][j] = simplify(expand(m[i][j]))
 
     m = rref(m)
-    
+
     for i in range(len(m)):
         for j in range(len(m[i])):
             m[i][j] = fraction(m[i][j])
-    
+
     output = []
     for index, row in enumerate(m):
         if not all(item == 0 for item in row[:-1]):
@@ -88,26 +87,17 @@ def linear(eqlist, fxconst):
         return tree_form("s_false")
     return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in output])
 def order_collinear_indices(points, idx):
-    """
-    Arrange a subset of collinear points (given by indices) along their line.
     
-    points: list of (x, y) tuples
-    idx: list of indices referring to points
-    Returns: list of indices sorted along the line
-    """
     if len(idx) <= 1:
         return idx[:]
-    
-    # Take first two points from the subset to define the line
+
     p0, p1 = points[idx[0]], points[idx[1]]
     dx, dy = p1[0] - p0[0], p1[1] - p0[1]
-    
-    # Projection factor for sorting
+
     def projection_factor(i):
         vx, vy = points[i][0] - p0[0], points[i][1] - p0[1]
         return compute((vx * dx + vy * dy) / (dx**2 + dy**2))
-    
-    # Sort indices by projection
+
     sorted_idx = sorted(idx, key=projection_factor)
     return list(sorted_idx)
 def linear_or(eq):
@@ -124,12 +114,12 @@ def linear_or(eq):
     for item in itertools.combinations(enumerate(eqlst), 2):
         x, y = item[0][0],  item[1][0]
         item = [item[0][1], item[1][1]]
-        
+
         out = linear_solve(TreeNode("f_and", list(item)))
 
         if out is None:
             return None
-        
+
         if out.name == "f_and" and all(len(vlist(child)) == 1 for child in out.children) and set(vlist(out)) == set(v) and all(len(vlist(simplify(child))) >0 for child in out.children):
             t = {}
             for child in out.children:
@@ -151,7 +141,7 @@ def linear_solve(eq, lst=None):
     eq = simplify(eq)
     eqlist = []
     if eq.name =="f_and" and all(child.name == "f_eq" and child.children[1] == 0 for child in eq.children):
-        
+
         eqlist = [child.children[0] for child in eq.children]
     else:
         return eq
@@ -163,3 +153,4 @@ def linear_solve(eq, lst=None):
     if out is None:
         return None
     return simplify(out)
+

mathai/logic.py

@@ -108,7 +108,7 @@ def logic2(eq):
             if len(lst) == 1:
                 return lst[0]
             return TreeNode(eq.name, lst)
-    
+
     if eq.name in ["f_and", "f_or"] and any(child.children is not None and len(child.children)!=0 for child in eq.children):
         for i in range(len(eq.children),1,-1):
             for item in itertools.combinations(enumerate(eq.children), i):
@@ -159,7 +159,7 @@ def logic1(eq):
             A, B = dowhile(A, logic2), dowhile(B, logic2)
             return flatten_tree((A & B) | (A.fx("not") & B.fx("not")))
         if eq.name == "f_imply":
-            
+
             A, B = eq.children
             A, B = logic1(A), logic1(B)
             A, B = dowhile(A, logic2), dowhile(B, logic2)
@@ -171,32 +171,28 @@ def logic1(eq):
         return eq
     eq = helper(eq)
     eq = flatten_tree(eq)
-    
+
     if len(eq.children) > 2:
         lst = []
         l = len(eq.children)
 
-        # Handle last odd child directly
         if l % 2 == 1:
             last_child = eq.children[-1]
-            # expand/simplify only if needed
+
             if isinstance(last_child, TreeNode):
                 last_child = dowhile(last_child, logic2)
             lst.append(last_child)
             l -= 1
 
-        # Pairwise combine children
         for i in range(0, l, 2):
             left, right = eq.children[i], eq.children[i+1]
             pair = TreeNode(eq.name, [left, right])
             simplified = dowhile(logic1(pair), logic2)
             lst.append(simplified)
 
-        # If only one element left, just return it instead of nesting
         if len(lst) == 1:
             return flatten_tree(lst[0])
 
-        # Otherwise rewrap
         return flatten_tree(TreeNode(eq.name, lst))
 
     if eq.name == "f_and":
@@ -228,3 +224,4 @@ def logic1(eq):
             out = out.children[0]
         return flatten_tree(out)
     return TreeNode(eq.name, [logic1(child) for child in eq.children])
+

mathai/matrix.py

@@ -3,7 +3,6 @@ import copy
 from .simplify import simplify
 import itertools
 
-# ---------- tree <-> python list ----------
 def tree_to_py(node):
     if node.name=="f_list":
         return [tree_to_py(c) for c in node.children]
@@ -14,16 +13,13 @@ def py_to_tree(obj):
         return TreeNode("f_list",[py_to_tree(x) for x in obj])
     return obj
 
-# ---------- shape detection ----------
 def is_vector(x):
     return isinstance(x,list) and all(isinstance(item,TreeNode) for item in x)
 def is_mat(x):
     return isinstance(x,list) and all(isinstance(item,list) for item in x)
 def is_matrix(x):
     return isinstance(x, list) and all(isinstance(item, list) and (is_mat(item) or is_vector(item)) for item in x)
-           
 
-# ---------- algebra primitives ----------
 def dot(u,v):
     if len(u)!=len(v):
         raise ValueError("Vector size mismatch")
@@ -33,9 +29,7 @@ def dot(u,v):
     return s
 
 def matmul(A, B):
-    # A: n × m
-    # B: m × p
-    
+
     n = len(A)
     m = len(A[0])
     p = len(B[0])
@@ -54,7 +48,6 @@ def matmul(A, B):
                 )
     return C
 
-# ---------- promotion ----------
 def promote(node):
     if node.name=="f_list":
         return tree_to_py(node)
@@ -68,7 +61,7 @@ def contains_neg(node):
         if not contains_neg(child):
             return False
     return True
-# ---------- multiplication (fully simplified) ----------
+
 def multiply(left,right):
     if left == tree_form("d_1"):
         return right
@@ -83,17 +76,16 @@ def multiply(left,right):
         return simplify(left2.children[0]**(left2.children[1]+right2.children[1]))
     A,B = promote(left), promote(right)
 
-    # vector · vector
     if is_vector(A) and is_vector(B):
         return dot(A,B)
-    # matrix × matrix
+
     if is_matrix(A) and is_matrix(B):
         return py_to_tree(matmul(A,B))
-    # scalar × vector
+
     for _ in range(2):
         if contains_neg(A) and is_vector(B):
             return py_to_tree([TreeNode("f_mul",[A,x]) for x in B])
-        # scalar × matrix
+
         if contains_neg(A) and is_matrix(B):
             return py_to_tree([[TreeNode("f_mul",[A,x]) for x in row] for row in B])
         A, B = B, A
@@ -122,45 +114,16 @@ def matadd(A, B):
     ]
 def addition(left,right):
     A,B = promote(left), promote(right)
-    # vector + vector
+
     if is_vector(A) and is_vector(B):
         return add_vec(A,B)
-    # matrix + matrix
+
     if is_matrix(A) and is_matrix(B):
         return py_to_tree(matadd(A,B))
     return None
-'''
-def fold_wmul(eq):
-    if eq.name == "f_pow" and eq.children[1].name.startswith("d_"):
-        n = int(eq.children[1].name[2:])
-        if n == 1:
-            eq = eq.children[0]
-        elif n > 1:
-            tmp = promote(eq.children[0])
-            if is_matrix(tmp):
-                orig =tmp
-                for i in range(n-1):
-                    tmp = matmul(orig, tmp)
-                eq = py_to_tree(tmp)
-    elif eq.name in ["f_wmul", "f_add"]:
-        if len(eq.children) == 1:
-            eq = eq.children[0]
-        else:
-            i = len(eq.children)-1
-            while i>0:
-                if eq.name == "f_wmul":
-                    out = multiply(eq.children[i-1], eq.children[i])
-                else:
-                    out = addition(eq.children[i-1], eq.children[i])
-                if out is not None:
-                    eq.children.pop(i)
-                    eq.children.pop(i-1)
-                    eq.children.insert(i-1,out)
-                i = i-1
-    return TreeNode(eq.name, [fold_wmul(child) for child in eq.children])
-'''
+
 def fold_wmul(root):
-    # Post-order traversal using explicit stack
+
     stack = [(root, False)]
     newnode = {}
 
@@ -168,17 +131,15 @@ def fold_wmul(root):
         node, visited = stack.pop()
 
         if not visited:
-            # First time: push back as visited, then children
+
             stack.append((node, True))
             for child in node.children:
                 stack.append((child, False))
         else:
-            # All children already processed
+
             children = [newnode[c] for c in node.children]
             eq = TreeNode(node.name, children)
 
-            # ---- original rewrite logic ----
-
             if eq.name == "f_pow" and eq.children[1].name.startswith("d_"):
                 n = int(eq.children[1].name[2:])
                 if n == 1:
@@ -208,8 +169,6 @@ def fold_wmul(root):
                             eq.children.insert(i - 1, out)
                         i -= 1
 
-            # --------------------------------
-
             newnode[node] = eq
 
     return newnode[root]
@@ -223,3 +182,4 @@ def _matrix_solve(eq):
     return eq
 def matrix_solve(eq):
     return _matrix_solve(eq)
+