mathai 0.4.0__py3-none-any.whl → 0.6.9__py3-none-any.whl

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, ["f_wmul"])
+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)

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

mathai/parser.py

@@ -37,7 +37,7 @@ grammar = """
            | arithmetic "-" term   -> sub
            | term
 
-?term: term "*" power  -> mul
+?term: term "*" power  -> wmul
      | term "/" power  -> div
      | term "." power  -> dot
      | power
@@ -59,7 +59,7 @@ grammar = """
      | ESCAPED_STRING      -> string
      | CAPITAL_ID          -> matrix
 
-FUNC_NAME: "midpoint" | "ref" | "subs" | "try" | "forall" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
+FUNC_NAME: "midpoint" | "ref" | "subs" | "try" | "limit" | "forall" | "limitpinf" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
 
 VARIABLE: /[a-z]/ | "nabla" | "pi" | "kc" | "hbar" | "em" | "ec" | "anot" | "false" | "true"
 
@@ -85,7 +85,7 @@ def parse(equation, funclist=None):
 
     parser_main = Lark(grammar2, start='start', parser='lalr')
     parse_tree = parser_main.parse(equation)
-
+    
     # Convert Lark tree to TreeNode
     def convert_to_treenode(parse_tree):
         if isinstance(parse_tree, Tree):
@@ -130,7 +130,7 @@ def parse(equation, funclist=None):
         if tree_node.name == "pass_through":
             return fxchange(tree_node.children[0])
         return TreeNode(
-            "f_" + tree_node.name if tree_node.name in tmp3 + ["try", "ref", "sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
+            "f_" + tree_node.name if tree_node.name in tmp3 + ["limitpinf", "limit", "try", "ref", "sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","wmul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
             [fxchange(child) for child in tree_node.children]
         )
 
@@ -146,13 +146,19 @@ def parse(equation, funclist=None):
     for i, c in enumerate([chr(x+ord("A")) for x in range(0,26)]):
         tree_node = replace(tree_node, tree_form("d_"+c), tree_form("v_-"+str(i+1)))
         tree_node = replace(tree_node, tree_form("f_"+c), tree_form("v_-"+str(i+1)))
-
-    # Final recursive replacements
+    
     def rfx(tree_node):
         if tree_node.name[:3] == "d_c":
             return tree_form("v_" + str(int(tree_node.name[3:])+100))
         tree_node.children = [rfx(child) for child in tree_node.children]
         return tree_node
-
+    
     tree_node = rfx(tree_node)
+    tree_node = flatten_tree(tree_node, ["f_wmul"])
+    if TreeNode.matmul == True:
+        TreeNode.matmul = False
+        tree_node = use(tree_form(str_form(tree_node).replace("f_w","f_")))
+        TreeNode.matmul = True
+    else:
+        tree_node = tree_form(str_form(tree_node).replace("f_w","f_"))
     return tree_node

mathai/parsetab.py

@@ -0,0 +1,61 @@
+
+# parsetab.py
+# This file is automatically generated. Do not edit.
+# pylint: disable=W,C,R
+_tabversion = '3.10'
+
+_lr_method = 'LALR'
+
+_lr_signature = 'leftEQUIVleftIMPLYleftORleftANDleftEQLTGTLEGEleftPLUSMINUSleftTIMESDIVDOTrightPOWrightNOTUMINUSUPLUSAND CAPITAL_ID CNUMBER COMMA DIV DOT EQ EQUIV GE GT IMPLY LBRACK LE LPAREN LT MINUS NOT NUMBER OR PLUS POW RBRACK RPAREN STRING TIMES VARIABLEstart : exprexpr : expr EQUIV exprexpr : expr IMPLY exprexpr : expr OR exprexpr : expr AND exprexpr : NOT exprexpr : expr EQ expr\n            | expr LT expr\n            | expr GT expr\n            | expr LE expr\n            | expr GE exprexpr : expr PLUS expr\n            | expr MINUS exprexpr : expr TIMES expr\n            | expr DIV expr\n            | expr DOT exprexpr : expr POW exprexpr : MINUS expr %prec UMINUSexpr : PLUS expr %prec UPLUSexpr : atomexpr : LPAREN expr RPARENexpr : LBRACK expr_list RBRACKexpr : LBRACK RBRACKexpr_list : expr_list COMMA exprexpr_list : exprexpr : VARIABLE LPAREN expr_list RPARENatom : VARIABLE\n            | CAPITAL_ID\n            | NUMBER\n            | CNUMBER\n            | STRING'
+    
+_lr_action_items = {'NOT':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,]),'MINUS':([0,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,56,57,],[5,24,5,5,5,-20,5,5,-27,-28,-29,-30,-31,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,-6,-19,-18,24,-23,24,5,24,24,24,24,24,24,24,24,24,-12,-13,-14,-15,-16,-17,-21,-22,5,24,-26,]),'PLUS':([0,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,56,57,],[4,23,4,4,4,-20,4,4,-27,-28,-29,-30,-31,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,-6,-19,-18,23,-23,23,4,23,23,23,23,23,23,23,23,23,-12,-13,-14,-15,-16,-17,-21,-22,4,23,-26,]),'LPAREN':([0,3,4,5,7,8,9,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[7,7,7,7,7,7,36,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,]),'LBRACK':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,]),'VARIABLE':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,]),'CAPITAL_ID':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,]),'NUMBER':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,]),'CNUMBER':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,]),'STRING':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,]),'$end':([1,2,6,9,10,11,12,13,29,30,31,34,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,57,],[0,-1,-20,-27,-28,-29,-30,-31,-6,-19,-18,-23,-2,-3,-4,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,-26,]),'EQUIV':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[14,-20,-27,-28,-29,-30,-31,-6,-19,-18,14,-23,14,-2,-3,-4,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,14,-26,]),'IMPLY':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[15,-20,-27,-28,-29,-30,-31,-6,-19,-18,15,-23,15,15,-3,-4,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,15,-26,]),'OR':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[16,-20,-27,-28,-29,-30,-31,-6,-19,-18,16,-23,16,16,16,-4,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,16,-26,]),'AND':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[17,-20,-27,-28,-29,-30,-31,-6,-19,-18,17,-23,17,17,17,17,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,17,-26,]),'EQ':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[18,-20,-27,-28,-29,-30,-31,-6,-19,-18,18,-23,18,18,18,18,18,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,18,-26,]),'LT':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[19,-20,-27,-28,-29,-30,-31,-6,-19,-18,19,-23,19,19,19,19,19,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,19,-26,]),'GT':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[20,-20,-27,-28,-29,-30,-31,-6,-19,-18,20,-23,20,20,20,20,20,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,20,-26,]),'LE':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[21,-20,-27,-28,-29,-30,-31,-6,-19,-18,21,-23,21,21,21,21,21,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,21,-26,]),'GE':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[22,-20,-27,-28,-29,-30,-31,-6,-19,-18,22,-23,22,22,22,22,22,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,22,-26,]),'TIMES':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[25,-20,-27,-28,-29,-30,-31,-6,-19,-18,25,-23,25,25,25,25,25,25,25,25,25,25,25,25,-14,-15,-16,-17,-21,-22,25,-26,]),'DIV':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[26,-20,-27,-28,-29,-30,-31,-6,-19,-18,26,-23,26,26,26,26,26,26,26,26,26,26,26,26,-14,-15,-16,-17,-21,-22,26,-26,]),'DOT':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[27,-20,-27,-28,-29,-30,-31,-6,-19,-18,27,-23,27,27,27,27,27,27,27,27,27,27,27,27,-14,-15,-16,-17,-21,-22,27,-26,]),'POW':([2,6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[28,-20,-27,-28,-29,-30,-31,-6,-19,-18,28,-23,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,-21,-22,28,-26,]),'RPAREN':([6,9,10,11,12,13,29,30,31,32,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,55,56,57,],[-20,-27,-28,-29,-30,-31,-6,-19,-18,52,-23,-25,-2,-3,-4,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,57,-24,-26,]),'RBRACK':([6,8,9,10,11,12,13,29,30,31,33,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,56,57,],[-20,34,-27,-28,-29,-30,-31,-6,-19,-18,53,-23,-25,-2,-3,-4,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,-24,-26,]),'COMMA':([6,9,10,11,12,13,29,30,31,33,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,55,56,57,],[-20,-27,-28,-29,-30,-31,-6,-19,-18,54,-23,-25,-2,-3,-4,-5,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-21,-22,54,-24,-26,]),}
+
+_lr_action = {}
+for _k, _v in _lr_action_items.items():
+   for _x,_y in zip(_v[0],_v[1]):
+      if not _x in _lr_action:  _lr_action[_x] = {}
+      _lr_action[_x][_k] = _y
+del _lr_action_items
+
+_lr_goto_items = {'start':([0,],[1,]),'expr':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[2,29,30,31,32,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,35,56,]),'atom':([0,3,4,5,7,8,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,36,54,],[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,]),'expr_list':([8,36,],[33,55,]),}
+
+_lr_goto = {}
+for _k, _v in _lr_goto_items.items():
+   for _x, _y in zip(_v[0], _v[1]):
+       if not _x in _lr_goto: _lr_goto[_x] = {}
+       _lr_goto[_x][_k] = _y
+del _lr_goto_items
+_lr_productions = [
+  ("S' -> start","S'",1,None,None,None),
+  ('start -> expr','start',1,'p_start','parser.py',98),
+  ('expr -> expr EQUIV expr','expr',3,'p_expr_equiv','parser.py',105),
+  ('expr -> expr IMPLY expr','expr',3,'p_expr_imply','parser.py',109),
+  ('expr -> expr OR expr','expr',3,'p_expr_or','parser.py',113),
+  ('expr -> expr AND expr','expr',3,'p_expr_and','parser.py',117),
+  ('expr -> NOT expr','expr',2,'p_expr_not','parser.py',121),
+  ('expr -> expr EQ expr','expr',3,'p_expr_cmp','parser.py',128),
+  ('expr -> expr LT expr','expr',3,'p_expr_cmp','parser.py',129),
+  ('expr -> expr GT expr','expr',3,'p_expr_cmp','parser.py',130),
+  ('expr -> expr LE expr','expr',3,'p_expr_cmp','parser.py',131),
+  ('expr -> expr GE expr','expr',3,'p_expr_cmp','parser.py',132),
+  ('expr -> expr PLUS expr','expr',3,'p_expr_add','parser.py',146),
+  ('expr -> expr MINUS expr','expr',3,'p_expr_add','parser.py',147),
+  ('expr -> expr TIMES expr','expr',3,'p_expr_mul','parser.py',154),
+  ('expr -> expr DIV expr','expr',3,'p_expr_mul','parser.py',155),
+  ('expr -> expr DOT expr','expr',3,'p_expr_mul','parser.py',156),
+  ('expr -> expr POW expr','expr',3,'p_expr_pow','parser.py',165),
+  ('expr -> MINUS expr','expr',2,'p_expr_uminus','parser.py',172),
+  ('expr -> PLUS expr','expr',2,'p_expr_uplus','parser.py',176),
+  ('expr -> atom','expr',1,'p_expr_atom','parser.py',183),
+  ('expr -> LPAREN expr RPAREN','expr',3,'p_expr_paren','parser.py',187),
+  ('expr -> LBRACK expr_list RBRACK','expr',3,'p_expr_list','parser.py',191),
+  ('expr -> LBRACK RBRACK','expr',2,'p_expr_list_single','parser.py',195),
+  ('expr_list -> expr_list COMMA expr','expr_list',3,'p_expr_list_list','parser.py',199),
+  ('expr_list -> expr','expr_list',1,'p_expr_list_item','parser.py',203),
+  ('expr -> VARIABLE LPAREN expr_list RPAREN','expr',4,'p_expr_func','parser.py',207),
+  ('atom -> VARIABLE','atom',1,'p_atom_var','parser.py',214),
+  ('atom -> CAPITAL_ID','atom',1,'p_atom_var','parser.py',215),
+  ('atom -> NUMBER','atom',1,'p_atom_var','parser.py',216),
+  ('atom -> CNUMBER','atom',1,'p_atom_var','parser.py',217),
+  ('atom -> STRING','atom',1,'p_atom_var','parser.py',218),
+]

mathai/printeq.py

@@ -1,5 +1,6 @@
 from .base import *
-from .simplify import solve
+from .factor import merge_sqrt
+from .simplify import simplify
 import copy
 from fractions import Fraction
 def abstractexpr(eq):
@@ -11,24 +12,26 @@ def abstractexpr(eq):
         
         lst = factor_generation(eq)
         deno = [item.children[0]**int(item.children[1].name[3:]) for item in lst if item.name == "f_pow" and item.children[1].name[:3] == "d_-"]
-        if eq.name == "f_mul" and any(item.name[:2] == "d_" and int(item.name[2:]) < 0 for item in lst):
-            return solve(-eq).fx("neg")
+        if eq.name == "f_mul" and any(frac(item) is not None and frac(item) < 0 for item in lst):
+            return simplify(-eq, False).fx("neg")
         if deno != []:
             
             num = [item for item in lst if item.name != "f_pow" or item.children[1].name[:3] != "d_-"]
             if num == []:
                 num = [tree_form("d_1")]
-            return TreeNode("f_div", [solve(product(num)), solve(product(deno))])
+            return TreeNode("f_div", [simplify(product(num), False), simplify(product(deno), False)])
     
     
     return TreeNode(eq.name, [abstractexpr(child) for child in eq.children])
 
 def printeq_str(eq):
-    return str(dowhile(eq, abstractexpr))
+    if eq is None:
+        return None
+    eq = merge_sqrt(eq)
+    return string_equation(str_form(dowhile(eq, abstractexpr)))
+def printeq_obj(self):
+    return printeq_str(self)
 
 def printeq(eq):
     print(printeq_str(eq))
-
-def printeq_log(lst):
-    for item in lst:
-        print("  "*item[0] + item[1])
+TreeNode.__repr__ = printeq_obj