mathai 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

mathai/structure.py

@@ -1,103 +1,103 @@
-import itertools
-from .simplify import solve, simplify
-from .base import *
-
-def structure(equation, formula, formula_out=None, only_const=False):
-    varlist = {}
-    def helper(equation, formula):
-        nonlocal varlist
-        if formula.name[:2] == "v_" and int(formula.name[2:])< 0:
-            if formula.name in varlist.keys():
-                return varlist[formula.name] == equation
-            else:
-                varlist[formula.name] = equation
-                return True
-        if equation.name != formula.name:
-            return False
-        if len(equation.children) != len(formula.children):
-            return False
-        return all(helper(equation.children[i], formula.children[i]) for i in range(len(equation.children)))
-    def lst(formula):
-        out = set()
-        
-        formula = conversion(formula)
-        def helper(node):
-            if not node.children:
-                return [node]
-            child_groups = [tuple(node.children)]
-            if node.name in ["f_addw", "f_mulw"]:
-                child_groups = list(itertools.permutations(node.children))
-            results = []
-            for children in child_groups:
-                child_perms = [helper(child) for child in children]
-                for combo in itertools.product(*child_perms):
-                    results.append(TreeNode(node.name, list(combo)))
-            return results
-        def conversionrev(node):
-            if node.name == "f_addw":
-                node.name = "f_add"
-            elif node.name == "f_mulw":
-                node.name = "f_mul"
-            return TreeNode(node.name, [conversionrev(child) for child in node.children])
-        for tree in helper(formula):
-            out.add(tree)
-        return list(out)
-    def conversion(node):
-        if node.name == "f_add":
-            node.name = "f_addw"
-        elif node.name == "f_mul":
-            node.name = "f_mulw"
-        return TreeNode(node.name, [conversion(child) for child in node.children])
-    def conversionrev(node):
-        if node.name == "f_addw":
-            node.name = "f_add"
-        elif node.name == "f_mulw":
-            node.name = "f_mul"
-        return TreeNode(node.name, [conversionrev(child) for child in node.children])
-    equation = conversion(equation)
-    if formula_out is not None:
-        formula_out = conversion(formula_out)
-    for item in lst(formula):
-        varlist = {}
-        if helper(equation, item):
-            if only_const and any("v_" in str_form(varlist[key]) for key in varlist.keys()):
-                continue
-            if formula_out is None:
-                return varlist
-            for key in varlist.keys():
-                formula_out = replace(formula_out, tree_form(key), varlist[key])
-            
-            return conversionrev(formula_out)
-    return None
-
-def transform_formula(equation, wrt, formula_list, var, expr):
-    
-    var2 = str(tree_form(wrt))
-    if var != var2:
-        formula_list =  [[replace(y, tree_form("v_0"), tree_form(wrt)) for y in x] for x in formula_list]
-        expr = [[replace(item, tree_form("v_0"), tree_form(wrt)) for item in item2] for item2 in expr]
-    for item in formula_list:
-        item = list(item)
-        orig = copy.deepcopy(item)
-        for item2 in itertools.product(*expr):
-            for i in range(2):
-                for j in range(len(expr)):
-                    item[i] = replace(item[i], expr[j][0], item2[j])
-            for i in range(2):
-                item[i] = solve(item[i])
-            out = None
-            p = False
-            if var != "":
-                p = True
-            try:
-                out = structure(copy.deepcopy(equation), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p)
-                if out is not None:
-                    out = simplify(out)
-                    
-            except:
-                out = None
-            
-            if out is not None:
-                return out
-            item = copy.deepcopy(orig)
-    return None
+import itertools
+from .simplify import solve, simplify
+from .base import *
+
+def structure(equation, formula, formula_out=None, only_const=False):
+    varlist = {}
+    def helper(equation, formula):
+        nonlocal varlist
+        if formula.name[:2] == "v_" and int(formula.name[2:])< 0:
+            if formula.name in varlist.keys():
+                return varlist[formula.name] == equation
+            else:
+                varlist[formula.name] = equation
+                return True
+        if equation.name != formula.name:
+            return False
+        if len(equation.children) != len(formula.children):
+            return False
+        return all(helper(equation.children[i], formula.children[i]) for i in range(len(equation.children)))
+    def lst(formula):
+        out = set()
+        
+        formula = conversion(formula)
+        def helper(node):
+            if not node.children:
+                return [node]
+            child_groups = [tuple(node.children)]
+            if node.name in ["f_addw", "f_mulw"]:
+                child_groups = list(itertools.permutations(node.children))
+            results = []
+            for children in child_groups:
+                child_perms = [helper(child) for child in children]
+                for combo in itertools.product(*child_perms):
+                    results.append(TreeNode(node.name, list(combo)))
+            return results
+        def conversionrev(node):
+            if node.name == "f_addw":
+                node.name = "f_add"
+            elif node.name == "f_mulw":
+                node.name = "f_mul"
+            return TreeNode(node.name, [conversionrev(child) for child in node.children])
+        for tree in helper(formula):
+            out.add(tree)
+        return list(out)
+    def conversion(node):
+        if node.name == "f_add":
+            node.name = "f_addw"
+        elif node.name == "f_mul":
+            node.name = "f_mulw"
+        return TreeNode(node.name, [conversion(child) for child in node.children])
+    def conversionrev(node):
+        if node.name == "f_addw":
+            node.name = "f_add"
+        elif node.name == "f_mulw":
+            node.name = "f_mul"
+        return TreeNode(node.name, [conversionrev(child) for child in node.children])
+    equation = conversion(equation)
+    if formula_out is not None:
+        formula_out = conversion(formula_out)
+    for item in lst(formula):
+        varlist = {}
+        if helper(equation, item):
+            if only_const and any("v_" in str_form(varlist[key]) for key in varlist.keys()):
+                continue
+            if formula_out is None:
+                return varlist
+            for key in varlist.keys():
+                formula_out = replace(formula_out, tree_form(key), varlist[key])
+            
+            return conversionrev(formula_out)
+    return None
+
+def transform_formula(equation, wrt, formula_list, var, expr):
+    
+    var2 = str(tree_form(wrt))
+    if var != var2:
+        formula_list =  [[replace(y, tree_form("v_0"), tree_form(wrt)) for y in x] for x in formula_list]
+        expr = [[replace(item, tree_form("v_0"), tree_form(wrt)) for item in item2] for item2 in expr]
+    for item in formula_list:
+        item = list(item)
+        orig = copy.deepcopy(item)
+        for item2 in itertools.product(*expr):
+            for i in range(2):
+                for j in range(len(expr)):
+                    item[i] = replace(item[i], expr[j][0], item2[j])
+            for i in range(2):
+                item[i] = solve(item[i])
+            out = None
+            p = False
+            if var != "":
+                p = True
+            try:
+                out = structure(copy.deepcopy(equation), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p)
+                if out is not None:
+                    out = simplify(out)
+                    
+            except:
+                out = None
+            
+            if out is not None:
+                return out
+            item = copy.deepcopy(orig)
+    return None

mathai/tool.py

@@ -1,35 +1,35 @@
-from .diff import diff
-from .expand import expand
-from .simplify import simplify
-from .base import *
-import math
-
-def poly(eq, to_compute):
-    def substitute_val(eq, val, var="v_0"):
-        eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
-        return eq
-    def inv(eq):
-        if eq.name == "f_pow" and eq.children[1] == tree_form("d_-1"):
-            return False
-        if eq.name == "f_abs":
-            return False
-        if any(not inv(child) for child in eq.children):
-            return False
-        return True
-    if not inv(eq):
-        return None
-    out = []
-    eq2 = eq
-    for i in range(10):
-        out.append(expand(simplify(eq2)))
-        eq2 = diff(eq2, to_compute)
-    for i in range(len(out)-1,-1,-1):
-        if out[i] == tree_form("d_0"):
-            out.pop(i)
-        else:
-            break
-    final = []
-    for index, item in enumerate(out):
-        final.append(substitute_val(item, 0, to_compute)/tree_form("d_"+str(math.factorial(index))))
-        
-    return [expand(simplify(item)) for item in final][::-1]
+from .diff import diff
+from .expand import expand
+from .simplify import simplify
+from .base import *
+import math
+
+def poly(eq, to_compute):
+    def substitute_val(eq, val, var="v_0"):
+        eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
+        return eq
+    def inv(eq):
+        if eq.name == "f_pow" and eq.children[1] == tree_form("d_-1"):
+            return False
+        if eq.name == "f_abs":
+            return False
+        if any(not inv(child) for child in eq.children):
+            return False
+        return True
+    if not inv(eq):
+        return None
+    out = []
+    eq2 = eq
+    for i in range(10):
+        out.append(expand(simplify(eq2)))
+        eq2 = diff(eq2, to_compute)
+    for i in range(len(out)-1,-1,-1):
+        if out[i] == tree_form("d_0"):
+            out.pop(i)
+        else:
+            break
+    final = []
+    for index, item in enumerate(out):
+        final.append(substitute_val(item, 0, to_compute)/tree_form("d_"+str(math.factorial(index))))
+        
+    return [expand(simplify(item)) for item in final][::-1]

mathai/trig.py

@@ -1,169 +1,169 @@
-import itertools
-from .simplify import solve, simplify
-from .base import *
-from .expand import expand
-from .structure import transform_formula
-from .parser import parse
-trig_sin_table = {
-    (0,1): parse("0"),
-    (1,6): parse("1/2"),
-    (1,4): parse("2^(1/2)/2"),   # π/4
-    (1,3): parse("3^(1/2)/2"),   # π/3
-    (1,2): parse("1"),           # π/2
-    (2,3): parse("3^(1/2)/2"),   # 2π/3
-    (3,4): parse("2^(1/2)/2"),   # 3π/4
-    (5,6): parse("1/2"),         # 5π/6
-    (1,1): parse("0")            # π
-}
-trig_cos_table = {
-    (0,1): parse("1"),           # 0
-    (1,6): parse("3^(1/2)/2"),   # π/6
-    (1,4): parse("2^(1/2)/2"),   # π/4
-    (1,3): parse("1/2"),         # π/3
-    (1,2): parse("0"),           # π/2
-    (2,3): parse("-1/2"),        # 2π/3
-    (3,4): parse("-2^(1/2)/2"),  # 3π/4
-    (5,6): parse("-1/2"),        # 5π/6
-    (1,1): parse("-1")           # π
-}
-
-for key in trig_cos_table.keys():
-    trig_cos_table[key] = simplify(trig_cos_table[key])
-for key in trig_sin_table.keys():
-    trig_sin_table[key] = simplify(trig_sin_table[key])
-def trig0(eq):
-    if eq is None:
-        return None
-    def isneg(eq):
-        if eq.name[:2] != "d_":
-            return False
-        if int(eq.name[2:]) >= 0:
-            return False
-        return True
-    def single_pi(lst):
-        if tree_form("d_0") in lst:
-            return 0, 1
-        count = 0
-        for item in lst:
-            if item == tree_form("s_pi"):
-                count += 1
-        if count != 1:
-            return None
-        eq = solve(product(lst)/tree_form("s_pi"))
-        out = frac(eq)
-        if out is None or out < 0:
-            return None
-        a,b= out.numerator, out.denominator
-        a %= 2*b
-        if a > b:       
-            a = 2*b - a
-        return a, b
-    if eq.name == "f_arctan":
-        if eq.children[0].name == "d_0":
-            return tree_form("d_0")
-    if eq.name == "f_log":
-        if eq.children[0].name == "d_1":
-            return tree_form("d_0")
-    if eq.name=="f_tan":
-        return eq.children[0].fx("sin")/eq.children[0].fx("cos")
-    if eq.name == "f_sec":
-        return eq.children[0].fx("cos")**-1
-    if eq.name == "f_cosec":
-        return eq.children[0].fx("sin")**-1
-    if eq.name == "f_cot":
-        return eq.children[0].fx("cos")/eq.children[0].fx("sin")
-    if eq.name == "f_sin":
-        lst = factor_generation(eq.children[0])
-        if any(isneg(item) for item in lst):
-            return -(eq.children[0]*-1).fx("sin")
-        out=single_pi(lst)
-        if out is not None:
-            return trig_sin_table[tuple(out)]
-    if eq.name == "f_cos":
-        lst = factor_generation(eq.children[0])
-        if any(isneg(item) for item in lst):
-            return (eq.children[0]*-1).fx("cos")
-        out=single_pi(lst)
-        if out is not None:
-            if tuple(out) in trig_cos_table.keys():
-                return trig_cos_table[tuple(out)]
-    return TreeNode(eq.name, [trig0(child) for child in eq.children])
-
-def product_to_sum(eq):
-    lst = factor_generation(eq)
-    if len(lst) == 1:
-        return lst[0]
-    if len(lst) == 2:
-        a, b = lst
-        if a.name == "f_sin" and b.name == "f_sin":
-            return ((a.children[0] - b.children[0]).fx("cos") - (a.children[0] + b.children[0]).fx("cos")) / tree_form("d_2")
-        elif a.name == "f_cos" and b.name == "f_cos":
-            return ((a.children[0] - b.children[0]).fx("cos") + (a.children[0] + b.children[0]).fx("cos")) / tree_form("d_2")
-        elif a.name == "f_sin" and b.name == "f_cos":
-            return ((a.children[0] + b.children[0]).fx("sin") + (a.children[0] - b.children[0]).fx("sin")) / tree_form("d_2")
-        elif a.name == "f_cos" and b.name == "f_sin":
-            return ((a.children[0] + b.children[0]).fx("sin") - (a.children[0] - b.children[0]).fx("sin")) / tree_form("d_2")
-    first, rest = lst[0], lst[1:]
-    s = tree_form("d_0")
-    eq = expand(simplify(first * product_to_sum(solve(TreeNode("f_mul", rest)))))
-    if eq.name == "f_add":
-        for child in eq.children:
-            s += product_to_sum(child)
-            s = simplify(s)
-    else:
-        s = eq
-    return s
-def trig_formula_init():
-    var = ""
-    formula_list = [(f"A*sin(B)+C*sin(B)", f"(A^2+C^2)^(1/2)*sin(B+arctan(C/A))"),\
-                    (f"sin(B+D)", f"sin(B)*cos(D)+cos(B)*sin(D)"),\
-                    (f"cos(B+D)", f"cos(B)*cos(D)-sin(B)*sin(D)"),\
-                    (f"cos(B)^2", f"1-sin(B)^2"),\
-                    (f"1/cos(B)^2", f"1/(1-sin(B)^2)"),\
-                    (f"cos(arcsin(B))", f"sqrt(1-B^2)"),\
-                    (f"sin(arccos(B))", f"sqrt(1-B^2)"),\
-                    (f"arccos(B)", f"pi/2-arcsin(B)")]
-    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
-    expr = [[parse("A"), parse("1")], [parse("B")], [parse("C"), parse("1")], [parse("D")]]
-    return [formula_list, var, expr]
-formula_gen4 = trig_formula_init()
-def trig3(eq):
-    def iseven(eq):
-        if eq.name[:2] != "d_":
-            return False
-        if int(eq.name[2:]) < 2 or int(eq.name[2:]) % 2 != 0:
-            return False
-        return True
-    
-    if eq.name == "f_sin":
-        lst = factor_generation(eq.children[0])
-        if any(iseven(item) for item in lst):
-            eq= 2*(eq.children[0]/2).fx("sin")*(eq.children[0]/2).fx("cos")
-    if eq.name == "f_cos":
-        lst = factor_generation(eq.children[0])
-        if any(iseven(item) for item in lst):
-            eq = (eq.children[0]/2).fx("cos")**2-(eq.children[0]/2).fx("sin")**2
-    eq = expand(simplify(eq))
-    return TreeNode(eq.name, [trig3(child) for child in eq.children])
-def trig1(equation):
-    equation = product_to_sum(equation)
-    return TreeNode(equation.name, [trig1(child) for child in equation.children])
-def trig4(eq):
-    out = transform_formula(eq, "v_0", formula_gen4[0], formula_gen4[1], formula_gen4[2])
-    if out is not None:
-        return trig4(out)
-    else:
-        return TreeNode(eq.name, [trig4(child) for child in eq.children])
-def trig2(eq):
-    if eq.name == "f_add":
-        for item in itertools.combinations(range(len(eq.children)), 2):
-            if all(eq.children[item2].name == "f_sin" for item2 in item):
-                a, b = eq.children[item[0]].children[0], eq.children[item[1]].children[0]
-                rest = [item2 for index, item2 in enumerate(eq.children) if index not in item]
-                if len(rest)==0:
-                    rest = tree_form("d_0")
-                else:
-                    rest = summation(rest)
-                two = tree_form("d_2")
-                return rest + two*((a+b)/two).fx("sin")*((a-b)/two).fx("cos")
-    return TreeNode(eq.name, [trig2(child) for child in eq.children])
+import itertools
+from .simplify import solve, simplify
+from .base import *
+from .expand import expand
+from .structure import transform_formula
+from .parser import parse
+trig_sin_table = {
+    (0,1): parse("0"),
+    (1,6): parse("1/2"),
+    (1,4): parse("2^(1/2)/2"),   # π/4
+    (1,3): parse("3^(1/2)/2"),   # π/3
+    (1,2): parse("1"),           # π/2
+    (2,3): parse("3^(1/2)/2"),   # 2π/3
+    (3,4): parse("2^(1/2)/2"),   # 3π/4
+    (5,6): parse("1/2"),         # 5π/6
+    (1,1): parse("0")            # π
+}
+trig_cos_table = {
+    (0,1): parse("1"),           # 0
+    (1,6): parse("3^(1/2)/2"),   # π/6
+    (1,4): parse("2^(1/2)/2"),   # π/4
+    (1,3): parse("1/2"),         # π/3
+    (1,2): parse("0"),           # π/2
+    (2,3): parse("-1/2"),        # 2π/3
+    (3,4): parse("-2^(1/2)/2"),  # 3π/4
+    (5,6): parse("-1/2"),        # 5π/6
+    (1,1): parse("-1")           # π
+}
+
+for key in trig_cos_table.keys():
+    trig_cos_table[key] = simplify(trig_cos_table[key])
+for key in trig_sin_table.keys():
+    trig_sin_table[key] = simplify(trig_sin_table[key])
+def trig0(eq):
+    if eq is None:
+        return None
+    def isneg(eq):
+        if eq.name[:2] != "d_":
+            return False
+        if int(eq.name[2:]) >= 0:
+            return False
+        return True
+    def single_pi(lst):
+        if tree_form("d_0") in lst:
+            return 0, 1
+        count = 0
+        for item in lst:
+            if item == tree_form("s_pi"):
+                count += 1
+        if count != 1:
+            return None
+        eq = solve(product(lst)/tree_form("s_pi"))
+        out = frac(eq)
+        if out is None or out < 0:
+            return None
+        a,b= out.numerator, out.denominator
+        a %= 2*b
+        if a > b:       
+            a = 2*b - a
+        return a, b
+    if eq.name == "f_arctan":
+        if eq.children[0].name == "d_0":
+            return tree_form("d_0")
+    if eq.name == "f_log":
+        if eq.children[0].name == "d_1":
+            return tree_form("d_0")
+    if eq.name=="f_tan":
+        return eq.children[0].fx("sin")/eq.children[0].fx("cos")
+    if eq.name == "f_sec":
+        return eq.children[0].fx("cos")**-1
+    if eq.name == "f_cosec":
+        return eq.children[0].fx("sin")**-1
+    if eq.name == "f_cot":
+        return eq.children[0].fx("cos")/eq.children[0].fx("sin")
+    if eq.name == "f_sin":
+        lst = factor_generation(eq.children[0])
+        if any(isneg(item) for item in lst):
+            return -(eq.children[0]*-1).fx("sin")
+        out=single_pi(lst)
+        if out is not None:
+            return trig_sin_table[tuple(out)]
+    if eq.name == "f_cos":
+        lst = factor_generation(eq.children[0])
+        if any(isneg(item) for item in lst):
+            return (eq.children[0]*-1).fx("cos")
+        out=single_pi(lst)
+        if out is not None:
+            if tuple(out) in trig_cos_table.keys():
+                return trig_cos_table[tuple(out)]
+    return TreeNode(eq.name, [trig0(child) for child in eq.children])
+
+def product_to_sum(eq):
+    lst = factor_generation(eq)
+    if len(lst) == 1:
+        return lst[0]
+    if len(lst) == 2:
+        a, b = lst
+        if a.name == "f_sin" and b.name == "f_sin":
+            return ((a.children[0] - b.children[0]).fx("cos") - (a.children[0] + b.children[0]).fx("cos")) / tree_form("d_2")
+        elif a.name == "f_cos" and b.name == "f_cos":
+            return ((a.children[0] - b.children[0]).fx("cos") + (a.children[0] + b.children[0]).fx("cos")) / tree_form("d_2")
+        elif a.name == "f_sin" and b.name == "f_cos":
+            return ((a.children[0] + b.children[0]).fx("sin") + (a.children[0] - b.children[0]).fx("sin")) / tree_form("d_2")
+        elif a.name == "f_cos" and b.name == "f_sin":
+            return ((a.children[0] + b.children[0]).fx("sin") - (a.children[0] - b.children[0]).fx("sin")) / tree_form("d_2")
+    first, rest = lst[0], lst[1:]
+    s = tree_form("d_0")
+    eq = expand(simplify(first * product_to_sum(solve(TreeNode("f_mul", rest)))))
+    if eq.name == "f_add":
+        for child in eq.children:
+            s += product_to_sum(child)
+            s = simplify(s)
+    else:
+        s = eq
+    return s
+def trig_formula_init():
+    var = ""
+    formula_list = [(f"A*sin(B)+C*sin(B)", f"(A^2+C^2)^(1/2)*sin(B+arctan(C/A))"),\
+                    (f"sin(B+D)", f"sin(B)*cos(D)+cos(B)*sin(D)"),\
+                    (f"cos(B+D)", f"cos(B)*cos(D)-sin(B)*sin(D)"),\
+                    (f"cos(B)^2", f"1-sin(B)^2"),\
+                    (f"1/cos(B)^2", f"1/(1-sin(B)^2)"),\
+                    (f"cos(arcsin(B))", f"sqrt(1-B^2)"),\
+                    (f"sin(arccos(B))", f"sqrt(1-B^2)"),\
+                    (f"arccos(B)", f"pi/2-arcsin(B)")]
+    formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
+    expr = [[parse("A"), parse("1")], [parse("B")], [parse("C"), parse("1")], [parse("D")]]
+    return [formula_list, var, expr]
+formula_gen4 = trig_formula_init()
+def trig3(eq):
+    def iseven(eq):
+        if eq.name[:2] != "d_":
+            return False
+        if int(eq.name[2:]) < 2 or int(eq.name[2:]) % 2 != 0:
+            return False
+        return True
+    
+    if eq.name == "f_sin":
+        lst = factor_generation(eq.children[0])
+        if any(iseven(item) for item in lst):
+            eq= 2*(eq.children[0]/2).fx("sin")*(eq.children[0]/2).fx("cos")
+    if eq.name == "f_cos":
+        lst = factor_generation(eq.children[0])
+        if any(iseven(item) for item in lst):
+            eq = (eq.children[0]/2).fx("cos")**2-(eq.children[0]/2).fx("sin")**2
+    eq = expand(simplify(eq))
+    return TreeNode(eq.name, [trig3(child) for child in eq.children])
+def trig1(equation):
+    equation = product_to_sum(equation)
+    return TreeNode(equation.name, [trig1(child) for child in equation.children])
+def trig4(eq):
+    out = transform_formula(eq, "v_0", formula_gen4[0], formula_gen4[1], formula_gen4[2])
+    if out is not None:
+        return trig4(out)
+    else:
+        return TreeNode(eq.name, [trig4(child) for child in eq.children])
+def trig2(eq):
+    if eq.name == "f_add":
+        for item in itertools.combinations(range(len(eq.children)), 2):
+            if all(eq.children[item2].name == "f_sin" for item2 in item):
+                a, b = eq.children[item[0]].children[0], eq.children[item[1]].children[0]
+                rest = [item2 for index, item2 in enumerate(eq.children) if index not in item]
+                if len(rest)==0:
+                    rest = tree_form("d_0")
+                else:
+                    rest = summation(rest)
+                two = tree_form("d_2")
+                return rest + two*((a+b)/two).fx("sin")*((a-b)/two).fx("cos")
+    return TreeNode(eq.name, [trig2(child) for child in eq.children])