mathai 0.6.0__py3-none-any.whl

mathai/linear.py

@@ -0,0 +1,165 @@
+from .inverse import inverse
+import itertools
+from .diff import diff
+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):
+    rows, cols = len(matrix), len(matrix[0])
+    lead = 0
+    for r in range(rows):
+        if lead >= cols:
+            return matrix
+        i = r
+        while ss(matrix[i][lead]) == tree_form("d_0"):
+            i += 1
+            if i == rows:
+                i = r
+                lead += 1
+                if lead == cols:
+                    return matrix
+        matrix[i], matrix[r] = matrix[r], matrix[i]
+        lv = matrix[r][lead]
+        matrix[r] = [ss(m / lv) for m in matrix[r]]
+        for i in range(rows):
+            if i != r:
+                lv = matrix[i][lead]
+                matrix[i] = [ss(m - lv * n) for m, n in zip(matrix[i], matrix[r])]
+        lead += 1
+    return matrix
+def islinear(eq, fxconst):
+    eq =simplify(eq)
+    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):
+    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
+        if eq.name[:2] == "v_" and fxconst(eq):
+            vl.append(eq.name)
+        for child in eq.children:
+            varlist(child, 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 = []
+    for eq in eqlist:
+        s = copy.deepcopy(eq)
+        row = []
+        for v in vl:
+            row.append(diff(eq, v))
+            s = replace(s, tree_form(v), tree_form("d_0"))
+        row.append(s)
+        m.append(row)
+    for i in range(len(m)):
+        for j in range(len(m[i])):
+            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]):
+            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")])
+    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)))
+
+        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]))))
+
+    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))
+    if out is None:
+        return None
+    return simplify(out)

mathai/logic.py

@@ -0,0 +1,230 @@
+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
+     if eq.name in ["f_eq", "f_lt", "f_gt" "f_ge"] and eq.children[1].name[:2]=="d_" and eq.children[0].name[:2]=="d_":
+        a, b = int(eq.children[0].name[2:]), int(eq.children[1].name[2:])
+        if eq.name == "f_eq":
+            return tree_form("s_true") if a==b else tree_form("s_false")
+        if eq.name == "f_ge":
+            return tree_form("s_true") if a>=b else tree_form("s_false")
+        if eq.name == "f_lt":
+            return tree_form("s_true") if a < b else tree_form("s_false")
+     if eq.name == "f_ge":
+        return TreeNode("f_gt", eq.children) | TreeNode("f_eq", eq.children)
+
+     if eq.name == "f_gt":
+        return TreeNode("f_lt", eq.children).fx("not") & TreeNode("f_eq", eq.children).fx("not")
+
+     if eq.name == "f_le":
+        return TreeNode("f_lt", eq.children) | TreeNode("f_eq", eq.children)
+     return TreeNode(eq.name, [logic0(child) for child in eq.children])
+def logic3(eq):
+    if eq.name == "f_forall" and eq.children[1] in [tree_form("s_true"), tree_form("s_false")]:
+        return eq.children[1]
+    if eq.name == "f_not" and eq.children[0].name == "f_exist":
+        return TreeNode("f_forall", [eq.children[0].children[0], eq.children[0].children[1].fx("not")])
+    if eq.name == "f_exist" and eq.children[1].name == "f_or":
+        return TreeNode("f_or", [TreeNode("f_exist", [eq.children[0], child]) for child in eq.children[1].children])
+    if eq.name == "f_forall" and eq.children[1].name == "f_and":
+        return TreeNode("f_and", [TreeNode("f_forall", [eq.children[0], child]) for child in eq.children[1].children])
+    if eq.name == "f_exist":
+        return TreeNode("f_forall", [eq.children[0], eq.children[1].fx("not")]).fx("not")
+    return TreeNode(eq.name, [logic3(child) for child in eq.children])
+def logic2(eq):
+    if eq.name in ["f_exist", "f_forall"]:
+        return TreeNode(eq.name, [eq.children[0], logic2(eq.children[1])])
+    if eq.name not in ["f_and", "f_or", "f_not", "f_imply", "f_equiv"]:
+        return eq
+    def convv(eq):
+        if eq == tree_form("s_true"):
+            return True
+        if eq == tree_form("s_false"):
+            return False
+        return None
+    def conv2(val):
+        if val:
+            return tree_form("s_true")
+        return tree_form("s_false")
+    if all(convv(child) is not None for child in eq.children):
+        if eq.name == "f_not":
+            return conv2(not convv(eq.children[0]))
+        elif eq.name == "f_or":
+            return conv2(convv(eq.children[0]) or convv(eq.children[1]))
+        elif eq.name == "f_and":
+            return conv2(convv(eq.children[0]) and convv(eq.children[1]))
+    if eq == tree_form("s_false").fx("not"):
+        return tree_form("s_true")
+    if eq.name == "f_not":
+        if eq.children[0].name == "f_not":
+            return eq.children[0].children[0]
+        elif eq.children[0].name in ["f_or", "f_and"]:
+            out = TreeNode({"f_or":"f_and", "f_and":"f_or"}[eq.children[0].name], [])
+            for child in eq.children[0].children:
+                out.children.append(child.fx("not"))
+            return out
+    if eq.name in ["f_and", "f_or"]:
+        for i in range(len(eq.children)):
+            for j in range(len(eq.children)):
+                if i ==j:
+                    continue
+                if eq.children[i] == eq.children[j].fx("not"):
+                    eq2 = copy.deepcopy(eq)
+                    eq2.children.pop(max(i, j))
+                    eq2.children.pop(min(i, j))
+                    eq2.children.append({"f_or":tree_form("s_true"), "f_and":tree_form("s_false")}[eq.name])
+                    if len(eq2.children) == 1:
+                        return eq2.children[0]
+                    return eq2
+    if eq.name in ["f_and", "f_or"]:
+        for i in range(len(eq.children)):
+            if eq.children[i] == tree_form("s_false"):
+                eq2 = copy.deepcopy(eq)
+                eq2.children.pop(i)
+                if eq.name == "f_and":
+                    return tree_form("s_false")
+                if len(eq2.children) == 1:
+                    return eq2.children[0]
+                return eq2
+            elif eq.children[i] == tree_form("s_true"):
+                eq2 = copy.deepcopy(eq)
+                eq2.children.pop(i)
+                if eq.name == "f_or":
+                    return tree_form("s_true")
+                if len(eq2.children) == 1:
+                    return eq2.children[0]
+                return eq2
+    if eq.name in ["f_and", "f_or"]:
+        lst = remove_duplicates_custom(eq.children, lambda x,y: x==y)
+        if len(lst) < len(eq.children):
+            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):
+                op = "f_and"
+                if eq.name == "f_and":
+                    op = "f_or"
+                item3 = []
+                for item4 in item:
+                    item3.append(item4[0])
+                item5 = []
+                for item4 in item:
+                    item5.append(item4[1])
+                item = item5
+                out = None
+                for j in range(len(item)):
+                    out = set(item[j].children)
+                    for item2 in item:
+                        if item2.name == op:
+                            out = out & set(item2.children)
+                        else:
+                            out = out & set([item2])
+                    if out == set(item[j].children):
+                        break
+                    out = None
+                if out is None:
+                    continue
+                out = list(out)
+                if out == []:
+                    continue
+                if len(out) != 1:
+                    out = [TreeNode(op, out)]
+                for item4 in list(set(range(len(eq.children))) - set(item3)):
+                    out.append(eq.children[item4])
+                if len(out) == 1:
+                    return out[0]
+                output = flatten_tree(TreeNode(eq.name, out))
+                return output
+    return TreeNode(eq.name, [flatten_tree(logic2(child)) for child in eq.children])
+def logic1(eq):
+    def helper(eq):
+        if eq.name in ["f_exist", "f_forall"]:
+            return TreeNode(eq.name, [eq.children[0], logic1(eq.children[1])])
+        if eq.name not in ["f_and", "f_or", "f_not", "f_imply", "f_equiv"]:
+            return eq
+        if eq.name == "f_equiv":
+            A, B = eq.children
+            A, B = logic1(A), logic1(B)
+            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)
+            return flatten_tree(A.fx("not") | B)
+        return TreeNode(eq.name, [helper(child) for child in eq.children])
+    if eq.name in ["f_exist", "f_forall"]:
+        return TreeNode(eq.name, [eq.children[0], logic1(eq.children[1])])
+    if eq.name not in ["f_and", "f_or", "f_not", "f_imply", "f_equiv"]:
+        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":
+        lst= []
+        for child in eq.children:
+            if child.name == "f_or":
+                lst.append(child.children)
+            else:
+                lst.append([child])
+        out = TreeNode("f_or", [])
+        for item in itertools.product(*lst):
+            c = TreeNode("f_and", list(item))
+            out.children.append(c)
+        if len(out.children) == 1:
+            out = out.children[0]
+        return flatten_tree(out)
+    elif eq.name == "f_or":
+        lst= []
+        for child in eq.children:
+            if child.name == "f_and":
+                lst.append(child.children)
+            else:
+                lst.append([child])
+        out = TreeNode("f_and", [])
+        for item in itertools.product(*lst):
+            c = TreeNode("f_or", list(item))
+            out.children.append(c)
+        if len(out.children) == 1:
+            out = out.children[0]
+        return flatten_tree(out)
+    return TreeNode(eq.name, [logic1(child) for child in eq.children])

mathai/matrix.py

@@ -0,0 +1,22 @@
+def uncommute(eq, inside=False):
+    if not inside and eq.name in ["f_add", "f_mul"]:
+        return TreeNode(eq.name[:2]+"w"+eq.name[2:], [uncommute(child) for child in eq.children])
+    return TreeNode(eq.name, [uncommute(child, True) if eq.name == "f_list" else uncommute(child, inside) for child in eq.children])
+
+def matrix_solve(eq):
+    if eq.name == "f_wadd":
+        output = None
+        output2 = []
+        for child in eq.children:
+            if child.name == "f_list":
+                if output is None:
+                    output = []
+                    for i in range(len(child.children)):
+                        output.append([child.children[i]])
+                else:
+                    for i in range(len(child.children)):
+                        output[i] += [child.children[i]]
+                output.append(child)
+            else:
+                output2.append(child)
+        output = [summation(item) for item in output]

mathai/ode.py

@@ -0,0 +1,124 @@
+from .factor import factor
+from .expand import expand
+from .base import *
+from .fraction import fraction
+from .simplify import simplify
+import copy
+
+def inversediff(lhs, rhs):
+    count = 4
+    while contain(rhs, tree_form("v_1")) or contain(lhs, tree_form("v_0")):
+        success = False
+        if rhs.name == "f_add":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_0")) or str_form(tree_form("v_1").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs - rhs.children[i]
+                    rhs.children.pop(i)
+        elif rhs.name == "f_mul":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_0")):
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs / rhs.children[i]
+                    rhs.children.pop(i)
+        if len(rhs.children) == 1:
+            rhs = rhs.children[0]
+        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
+        if rhs.name == "f_add":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_1")) or str_form(tree_form("v_0").fx("dif")) in [str_form(x) for x in factor_generation(rhs.children[i])]:
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs - rhs.children[i]
+                    rhs.children.pop(i)
+        elif rhs.name == "f_mul":
+            for i in range(len(rhs.children)-1,-1,-1):
+                if not contain(rhs.children[i], tree_form("v_1")):
+                    if contain(rhs.children[i], tree_form("v_0")) or contain(rhs.children[i], tree_form("v_1")):
+                        success = True
+                    lhs = lhs / rhs.children[i]
+                    rhs.children.pop(i)
+        rhs, lhs = copy.deepcopy([simplify(lhs), simplify(rhs)])
+        if not success:
+            lhs, rhs = factor(lhs),factor(rhs)
+        count -= 1
+        if count == 0:
+            return simplify(e0(lhs-rhs))
+    return simplify(e0(lhs-rhs))
+
+intconst = ["v_"+str(i) for i in range(101,150)]
+def allocvar():
+    global intconst
+    return tree_form(intconst.pop(0))
+
+def epowersplit(eq):
+    if eq.name == "f_pow" and eq.children[1].name == "f_add":
+        return product([eq.children[0]**child for child in eq.children[1].children])
+    return TreeNode(eq.name, [epowersplit(child) for child in eq.children])
+def esolve(s):
+    if s.name == "f_add" and "f_log" in str_form(s):
+        return product([tree_form("s_e")**child for child in s.children]) - tree_form("d_1")
+    return TreeNode(s.name, [esolve(child) for child in s.children])
+def diffsolve_sep2(eq):
+    global tab
+    
+    s = []
+    eq = simplify(expand(eq))
+    eq = e1(eq)
+    
+    def vlor1(eq):
+        if contain(eq, tree_form("v_0")) and not contain(eq, tree_form("v_1")):
+            return True
+        if contain(eq, tree_form("v_1")) and not contain(eq, tree_form("v_0")):
+            return True
+        return False
+    if eq.name == "f_add" and all(vlor1(child) and [str_form(x) for x in factor_generation(copy.deepcopy(child))].count(str_form(tree_form(vlist(child)[0]).fx("dif")))==1 for child in eq.children):
+        for child in eq.children:
+            v = vlist(child)[0]
+            v2 = tree_form(v).fx("dif")
+            child = replace(child, v2, tree_form("d_1"))
+            child = simplify(child)
+            
+            
+            tmp6 = TreeNode("f_integrate", [child, tree_form(v)])
+            s.append(tmp6)
+            
+            if s[-1] is None:
+                return None
+        s.append(allocvar())
+    else:
+        return None
+    s = summation(s)
+    s = simplify(e0(s))
+    
+    return groupe(s)
+def e0(eq):
+    return TreeNode("f_eq", [eq, tree_form("d_0")])
+def e1(eq):
+    if eq.name == "f_eq":
+        eq = eq.children[0]
+    return eq
+def groupe(eq):
+    eq = esolve(eq)
+    eq = simplify(eq)
+    eq = fraction(eq)
+    eq = simplify(eq)
+    eq = epowersplit(eq)
+    return eq
+
+def diffsolve_sep(eq):
+    eq = epowersplit(eq)
+
+    eq = inversediff(tree_form("d_0"), eq.children[0].copy_tree())
+    return eq
+
+def diffsolve(eq):
+    orig = eq.copy_tree()
+
+    
+    eq = diffsolve_sep2(eq)
+    if eq is None:
+        return orig
+    return eq