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

mathai/limit.py

@@ -1,12 +1,12 @@
 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
 from .fraction import fraction
-from .printeq import printeq_str
+from .printeq import printeq
 tab=0
 def substitute_val(eq, val, var="v_0"):
     eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
@@ -33,100 +33,124 @@ def check(num, den, var):
         return simplify(n/d)
     return False
 def lhospital(num, den, steps,var):
-    logs = []
     
     out = check(num, den, var)
     
     if isinstance(out, TreeNode):
-        return out,[]
+        return out
     for _ in range(steps):
         num2, den2 = map(lambda e: simplify(diff(e, var)), (num, den))
         out = check(num2, den2, var)
         if out is True:
             num, den = num2, den2
-            logs += [(0,"lim x->0 "+printeq_str(simplify(num/den)))]
             continue
         if out is False:
             eq2 = simplify(fraction(simplify(num/den)))
-            return eq2,logs
-        return out,logs
+            return eq2
+        return out
 def lhospital2(eq, var):
     eq=  simplify(eq)
     if eq is None:
         return None
     if not contain(eq, tree_form(var)):
-        return eq,[]
+        return eq
     num, dem = [simplify(item) for item in num_dem(eq)]
     if num is None or dem is None:
-        return eq,[]
+        return eq
     
     return lhospital(num, dem, 10,var)
-ls = [parse("sin(A)"), parse("A^B-1"),parse("log(1+A)"), parse("cos(A)")]
-ls= [simplify(item) for item in ls]
-
-def approx(eq, var):
-    n, d= num_dem(eq)
-    n, d = solve(n), solve(d)
-    n, d = expand(n), expand(d)
-    out = []
-    for equation in [n, d]:
-        for item in factor_generation(equation):
-            tmp = structure(item, ls[0])
-            if tmp is not None and contain(tmp["v_-1"], var):
-                item2 = substitute_val(tmp["v_-1"], 0, var.name)
-                if tree_form("d_0") == expand(simplify(item2)):
-                    equation = equation/item
-                    equation = equation*tmp["v_-1"]
-                    break
-                elif tree_form("d_0") == expand(simplify(tree_form("s_pi") - item2)):
-                    equation = equation/item
-                    equation = equation*(tree_form("s_pi") - tmp["v_-1"])
-                    break
-            tmp = structure(item, ls[1])
-            if tmp is not None and contain(tmp["v_-1"], var) and not contain(tmp["v_-2"], var):
-                item2 = substitute_val(tmp["v_-1"], 0, var.name)
-                item2 = expand(solve(item2))
-                if tree_form("d_0") == item2:
-                    equation = equation/item
-                    equation = solve(equation*tmp["v_-1"]*tmp["v_-2"].fx("log"))
-                    break
-            tmp = structure(item, ls[2])
-            if tmp is not None and contain(tmp["v_-1"], var):
-                                
-                item2 = substitute_val(tmp["v_-1"], 0, var.name)
-                item2 = expand(solve(item2))
-                if tree_form("d_0") == item2:
-                    equation = equation/item
-                    equation = solve(equation*tmp["v_-1"])
-                    break
-            tmp = structure(item, ls[3])
-            if tmp is not None and contain(tmp["v_-1"], var):
-                item2 = substitute_val(item, 0, var.name)
-                
-                if tree_form("d_0") == expand(solve(item2)):
-                    
-                    equation = equation/item
-                    equation = equation*(tree_form("d_1") - tmp["v_-1"]**tree_form("d_2"))
-                    break
+def limit0(equation):
+    if equation.name == "f_ref":
+        return equation
+    eq2 = equation
+    g = ["f_limit", "f_limitpinf", "f_limitninf"]
+    if eq2.name in g 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)]
+        if lst_const != []:
+            
+            equation = product([item for item in lst if contain(item, wrt)]).copy_tree()
+            const = product(lst_const)
+            const = simplify(const)
+            
+            if not contain(const, tree_form("s_i")):
                 
-        equation = solve(equation)
-        out.append(equation)
-    return simplify(out[0]/out[1])
-def approx_limit(equation, var):
-    return dowhile(equation, lambda x: approx(x, var))
+                return limit0(TreeNode(equation.name,[equation, wrt])) *const
+        equation = eq2
+    return TreeNode(equation.name, [limit0(child)  for child in equation.children])
+def limit2(eq):
+    g = ["f_limit", "f_limitpinf", "f_limitninf"]
+    if eq.name in g and eq.children[0].name == "f_add":
+        eq = summation([TreeNode(eq.name, [child, eq.children[1]]) for child in eq.children[0].children])
+    return TreeNode(eq.name, [limit2(child) for child in eq.children])
+def limit1(eq):
+    if eq.name == "f_limit":
+        a, b = limit(eq.children[0], eq.children[1].name)
+        if b:
+            return a
+        else:
+            return TreeNode(eq.name, [a, eq.children[1]])
+    return TreeNode(eq.name, [limit1(child) for child in eq.children])
+def fxinf(eq):
+    if eq is None:
+        return None
+    if eq.name == "f_add":
+        if tree_form("s_inf") in eq.children and -tree_form("s_inf") in eq.children:
+            return None
+        if tree_form("s_inf") in eq.children:
+            return tree_form("s_inf")
+        if -tree_form("s_inf") in eq.children:
+            return -tree_form("s_inf")
+    if eq.name == "f_mul":
+        lst = factor_generation(eq)
+        if tree_form("s_inf") in lst:
+            eq = TreeNode(eq.name, [dowhile(child, fxinf) for child in eq.children])
+            if None in eq.children:
+                return None
+            lst = factor_generation(eq)
+            if tree_form("d_0") in lst:
+                return tree_form("d_0")
+            lst2 = [item for item in lst if "v_" in str_form(item)]
+            sign = True
+            if len([item for item in lst if "v_" not in str_form(item) and not contain(item, tree_form("s_inf")) and compute(item)<0]) % 2==1:
+                sign = False
+            if lst2 == []:
+                if sign:
+                    return tree_form("s_inf")
+                else:
+                    return -tree_form("s_inf")
+    if eq.name == "f_pow":
+        if "v_" not in str_form(eq.children[0]) and not contain(eq.children[0], tree_form("s_inf")) and compute(eq.children[0])>0:
+            if eq.children[1] == -tree_form("s_inf"):
+                return tree_form("d_0")
+            
+    eq = TreeNode(eq.name, [fxinf(child) for child in eq.children])
+    if None in eq.children:
+        return None
+    return eq
+def limit3(eq):
+    
+    if eq.name == "f_limitpinf":
+        if not contain(eq, eq.children[1]):
+            return eq.children[0]
+        eq2 = replace(eq.children[0], eq.children[1], tree_form("s_inf"))
+        eq2 = dowhile(eq2, fxinf)
+        if not contain(eq2, tree_form("s_inf")) and not contain(eq2, eq.children[1]):
+            return simplify(eq2)
+    return TreeNode(eq.name, [limit3(child) for child in eq.children])
 
 def limit(equation, var="v_0"):
-    logs = [(0,"lim x->0 "+printeq_str(simplify(equation)))]
+    
     eq2 = dowhile(replace(equation, tree_form(var), tree_form("d_0")), lambda x: trig0(simplify(x)))
     if eq2 is not None and not contain(equation, tree_form(var)):
-        return eq2,logs
+        return eq2, True
     
-    equation, tmp = lhospital2(equation, var)
+    equation =  lhospital2(equation, var)
     equation = simplify(expand(simplify(equation)))
     if not contain(equation, tree_form(var)):
-        return equation,logs+tmp
-    '''
-    if equation.name == "f_add":
-        return simplify(summation([limit(child, var) for child in equation.children]))
-    '''
-    return equation,logs+tmp
+        return equation, True
+    
+    return equation, False

mathai/linear.py

@@ -1,9 +1,12 @@
+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 *
 from .factor import factorconst
+from .tool import poly
 def ss(eq):
     return dowhile(eq, lambda x: fraction(expand(simplify(x))))
 def rref(matrix):
@@ -31,38 +34,16 @@ def rref(matrix):
     return matrix
 def islinear(eq, fxconst):
     eq =simplify(eq)
-    if eq.name == "f_pow" and fxconst(eq):#"v_" in str_form(eq):
-        return False
-    for child in eq.children:
-        out = islinear(child, fxconst)
-        if not out:
-            return out
-    return True
+    if all(fxconst(tree_form(item)) and poly(eq, item) is not None and len(poly(eq, item)) <= 2 for item in vlist(eq)):
+        return True
+    return False
 def linear(eqlist, fxconst):
-    final = []
-    extra = []
-    for i in range(len(eqlist)-1,-1,-1):
-        if eqlist[i].name == "f_mul" and not islinear(expand2(eqlist[i]), fxconst):
-            if "v_" in str_form(eqlist[i]):
-                eqlist[i] = TreeNode("f_mul", [child for child in eqlist[i].children if fxconst(child)])
-            if all(islinear(child, fxconst) for child in eqlist[i].children):
-                for child in eqlist[i].children:
-                    extra.append(TreeNode("f_eq", [child, tree_form("d_0")]))
-                eqlist.pop(i)
-            else:
-                final.append(TreeNode("f_eq", [eqlist[i], tree_form("d_0")]))
-                eqlist.pop(i)
+    orig = [item.copy_tree() for item in eqlist]
+    #eqlist = [eq for eq in eqlist if fxconst(eq)]
     
-    if extra != []:
-        final.append(TreeNode("f_or", extra))
-    if eqlist == []:
-        if len(final)==1:
-            
-            return final[0]
-        return TreeNode("f_and", final)
-    eqlist = [eq for eq in eqlist if fxconst(eq)]
-    if not all(islinear(eq, fxconst) for eq in eqlist):
-        return TreeNode("f_and", copy.deepcopy(final+eqlist))
+    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
@@ -75,7 +56,7 @@ def linear(eqlist, fxconst):
     vl = list(set(vl))
     
     if len(vl) > len(eqlist):
-        return TreeNode("f_and", final+[TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
+        return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
     m = []
     for eq in eqlist:
         s = copy.deepcopy(eq)
@@ -94,63 +75,91 @@ def linear(eqlist, fxconst):
     for i in range(len(m)):
         for j in range(len(m[i])):
             m[i][j] = fraction(m[i][j])
-
-    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")
     
     output = []
     for index, row in enumerate(m):
-        count = 0
-        for item in row[:-1]:
-            if item == tree_form("d_1"):
-                count += 1
-                if count == 2:
-                    break
-            elif item == tree_form("d_0") and count == 1:
-                break
-        if count == 0:
-            continue
-        output.append(tree_form(vl[index])+row[-1])
-    if len(output) == 1 and len(final)==0:
+        if not all(item == 0 for item in row[:-1]):
+            output.append(summation([tree_form(vl[index2])*coeff for index2, coeff in enumerate(row[:-1])])+row[-1])
+        elif row[-1] != 0:
+            return tree_form("s_false")
+    if len(output) == 1:
         return TreeNode("f_eq", [output[0], tree_form("d_0")])
-    return TreeNode("f_and", final+[TreeNode("f_eq", [x, tree_form("d_0")]) for x in output])
+    if len(output) == 0:
+        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):
+    eqlst =[]
+    if eq.name != "f_or":
+        eqlst = [eq]
+    else:
+        eqlst = eq.children
+    v = vlist(eq)
+    p = []
+    line = {}
+    for i in range(len(eqlst)):
+        line[i] = []
+    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)))
 
-def rmeq(eq):
-    if eq.name == "f_eq":
-        return rmeq(eq.children[0])
-    return TreeNode(eq.name, [rmeq(child) for child in eq.children])
+        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:
+                t[v.index(vlist(child)[0])] = simplify(inverse(child.children[0], vlist(child)[0]))
+            t2 = []
+            for key in sorted(t.keys()):
+                t2.append(t[key])
+            t2 = tuple(t2)
+            if t2 not in p:
+                p.append(t2)
+            line[x] += [p.index(t2)]
+            line[y] += [p.index(t2)]
+    line2 = []
+    for key in sorted(line.keys()):
+        line2.append(order_collinear_indices(p, list(set(line[key]))))
 
-def mat0(eq, lst=None):
-    def findeq(eq):
-        out = []
-        if "f_list" not in str_form(eq) and "f_eq" not in str_form(eq):
-            return [str_form(eq)]
-        else:
-            for child in eq.children:
-                out += findeq(child)
-        return out
-    eqlist = findeq(eq)
-    eqlist = [tree_form(x) for x in eqlist]
-    eqlist = [rmeq(x) for x in eqlist]
-    eqlist = [TreeNode("f_mul", factor_generation(x)) for x in eqlist if x != tree_form("d_0")]
-    eqlist = [x.children[0] if len(x.children) == 1 else x for x in eqlist]
+    return v, p, line2, eqlst
+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
     out = None
-    
     if lst is None:
         out = linear(copy.deepcopy(eqlist), lambda x: "v_" in str_form(x))
     else:
         out = linear(copy.deepcopy(eqlist), lambda x: any(contain(x, item) for item in lst))
-    def rms(eq):
-        if eq.name in ["f_and", "f_or"] and len(eq.children) == 1:
-            return eq.children[0]
-        return TreeNode(eq.name, [rms(child) for child in eq.children])
-    return rms(out)
-def linear_solve(eq, lst=None):
-    if eq.name == "f_and":
-        eq2 = copy.deepcopy(eq)
-        eq2.name = "f_list"
-        return mat0(eq2, lst)
-    elif eq.name == "f_eq":
-        return mat0(eq, lst)
-    return TreeNode(eq.name, [linear_solve(child, lst) for child in eq.children])
+    if out is None:
+        return None
+    return simplify(out)

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

mathai/matrix.py

@@ -0,0 +1,228 @@
+from .base import *
+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]
+    return node
+
+def py_to_tree(obj):
+    if isinstance(obj,list):
+        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")
+    s = tree_form("d_0")
+    for a,b in zip(u,v):
+        s = TreeNode("f_add",[s,TreeNode("f_mul",[a,b])])
+    return s
+
+def matmul(A, B):
+    # A: n × m
+    # B: m × p
+    
+    n = len(A)
+    m = len(A[0])
+    p = len(B[0])
+
+    if m != len(B):
+        raise ValueError("Matrix dimension mismatch")
+
+    C = [[tree_form("d_0") for _ in range(p)] for _ in range(n)]
+
+    for i in range(n):
+        for j in range(p):
+            for k in range(m):
+                C[i][j] = TreeNode(
+                    "f_add",
+                    [C[i][j], TreeNode("f_mul", [A[i][k], B[k][j]])]
+                )
+    return C
+
+# ---------- promotion ----------
+def promote(node):
+    if node.name=="f_list":
+        return tree_to_py(node)
+    return node
+def contains_neg(node):
+    if isinstance(node, list):
+        return False
+    if node.name.startswith("v_-"):
+        return False
+    for child in node.children:
+        if not contains_neg(child):
+            return False
+    return True
+# ---------- multiplication (fully simplified) ----------
+def multiply(left,right):
+    if left == tree_form("d_1"):
+        return right
+    if right == tree_form("d_1"):
+        return left
+    left2, right2 = left, right
+    if left2.name != "f_pow":
+        left2 = left2 ** 1
+    if right2.name != "f_pow":
+        right2 = right2 ** 1
+    if left2.name == "f_pow" and right2.name == "f_pow" and left2.children[0]==right2.children[0]:
+        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
+    return None
+def add_vec(A, B):
+    if len(A) != len(B):
+        raise ValueError("Vector dimension mismatch")
+
+    return [
+        TreeNode("f_add", [A[i], B[i]])
+        for i in range(len(A))
+    ]
+def matadd(A, B):
+    if len(A) != len(B) or len(A[0]) != len(B[0]):
+        raise ValueError("Matrix dimension mismatch")
+
+    n = len(A)
+    m = len(A[0])
+
+    return [
+        [
+            TreeNode("f_add", [A[i][j], B[i][j]])
+            for j in range(m)
+        ]
+        for i in range(n)
+    ]
+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 = {}
+
+    while stack:
+        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:
+                    eq = eq.children[0]
+                elif n > 1:
+                    tmp = promote(eq.children[0])
+                    if is_matrix(tmp):
+                        orig = tmp
+                        for _ 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 -= 1
+
+            # --------------------------------
+
+            newnode[node] = eq
+
+    return newnode[root]
+
+def flat(eq):
+    return flatten_tree(eq)
+def use(eq):
+    return TreeNode(eq.name, [use(child) for child in eq.children])
+def _matrix_solve(eq):
+    if TreeNode.matmul == True:
+        TreeNode.matmul = False
+        eq = dowhile(eq, lambda x: fold_wmul(use(flat(x))))
+        TreeNode.matmul = True
+    return eq
+def matrix_solve(eq):
+    return _matrix_solve(eq)