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

mathai/console.py

@@ -1,84 +1,84 @@
-import copy
-from .expand import expand
-from .parser import parse
-from .printeq import printeq, printeq_log
-from .simplify import solve, simplify
-from .integrate import integrate, typesqint, typebyparts, typeintegrate
-from .diff import diff
-from .base import *
-from .factor import _factorconst, factor
-from .fraction import fraction
-from .inverse import inverse
-from .trig import trig0, trig1, trig2, trig3, trig4
-from .logic import logic0, logic1, logic2, logic3
-from .apart import apart
-
-def console():
-    eq = None
-    orig = None
-    while True:
-        command = input(">>> ")
-        try:
-            orig = copy.deepcopy(eq)
-            if command == "expand":
-                eq = expand(eq)
-            elif command.split(" ")[0] == "inverse":
-                eq=simplify(eq)
-                if eq.name == "f_eq":
-                    eq3 = eq.children[0]-eq.children[1]
-                    eq2 = parse(command.split(" ")[1])
-                    out = inverse(eq3, str_form(eq2))
-                    eq = TreeNode(eq.name, [eq2,out])
-            elif command == "apart":
-                eq = apart(eq, vlist(eq)[0])
-            elif command == "rawprint":
-                print(eq)
-            elif command == "logic0":
-                eq = logic0(eq)
-            elif command == "logic1":
-                eq = logic1(eq)
-            elif command == "logic2":
-                eq = logic2(eq)
-            elif command == "logic3":
-                eq = logic3(eq)
-            elif command == "trig0":
-                eq = trig0(eq)
-            elif command == "trig1":
-                eq = trig1(eq)
-            elif command == "factor":
-                eq = factor(eq)
-            elif command == "trig2":
-                eq = trig2(eq)
-            elif command == "trig3":
-                eq = trig3(eq)
-            elif command == "trig4":
-                eq = trig4(eq)
-            elif command == "simplify":
-                eq = _factorconst(eq)
-                eq = simplify(eq)
-            elif command == "fraction":
-                eq = fraction(eq)
-            elif command.split(" ")[0] in ["integrate", "sqint", "byparts"]:
-                if command.split(" ")[0] == "sqint":
-                    typesqint()
-                elif command.split(" ")[0] == "byparts":
-                    typebyparts()
-                elif command.split(" ")[0] == "integrate":
-                    typeintegrate()
-                out = integrate(eq, parse(command.split(" ")[1]).name)
-                if out is None:
-                    print("failed to integrate")
-                else:
-                    eq, logs = out
-                    eq = simplify(eq)
-                    printeq_log(logs)
-                    print()
-            elif command.split(" ")[0] == "diff":
-                eq = diff(eq, parse(command.split(" ")[1]).name)
-            else:
-                eq = parse(command)
-            eq = copy.deepcopy(eq)
-            printeq(eq)
-        except:
-            eq = copy.deepcopy(orig)
-            print("error")
+import copy
+from .expand import expand
+from .parser import parse
+from .printeq import printeq, printeq_log
+from .simplify import solve, simplify
+from .integrate import integrate, typesqint, typebyparts, typeintegrate
+from .diff import diff
+from .base import *
+from .factor import _factorconst, factor
+from .fraction import fraction
+from .inverse import inverse
+from .trig import trig0, trig1, trig2, trig3, trig4
+from .logic import logic0, logic1, logic2, logic3
+from .apart import apart
+
+def console():
+    eq = None
+    orig = None
+    while True:
+        command = input(">>> ")
+        try:
+            orig = copy.deepcopy(eq)
+            if command == "expand":
+                eq = expand(eq)
+            elif command.split(" ")[0] == "inverse":
+                eq=simplify(eq)
+                if eq.name == "f_eq":
+                    eq3 = eq.children[0]-eq.children[1]
+                    eq2 = parse(command.split(" ")[1])
+                    out = inverse(eq3, str_form(eq2))
+                    eq = TreeNode(eq.name, [eq2,out])
+            elif command == "apart":
+                eq = apart(eq, vlist(eq)[0])
+            elif command == "rawprint":
+                print(eq)
+            elif command == "logic0":
+                eq = logic0(eq)
+            elif command == "logic1":
+                eq = logic1(eq)
+            elif command == "logic2":
+                eq = logic2(eq)
+            elif command == "logic3":
+                eq = logic3(eq)
+            elif command == "trig0":
+                eq = trig0(eq)
+            elif command == "trig1":
+                eq = trig1(eq)
+            elif command == "factor":
+                eq = factor(eq)
+            elif command == "trig2":
+                eq = trig2(eq)
+            elif command == "trig3":
+                eq = trig3(eq)
+            elif command == "trig4":
+                eq = trig4(eq)
+            elif command == "simplify":
+                eq = _factorconst(eq)
+                eq = simplify(eq)
+            elif command == "fraction":
+                eq = fraction(eq)
+            elif command.split(" ")[0] in ["integrate", "sqint", "byparts"]:
+                if command.split(" ")[0] == "sqint":
+                    typesqint()
+                elif command.split(" ")[0] == "byparts":
+                    typebyparts()
+                elif command.split(" ")[0] == "integrate":
+                    typeintegrate()
+                out = integrate(eq, parse(command.split(" ")[1]).name)
+                if out is None:
+                    print("failed to integrate")
+                else:
+                    eq, logs = out
+                    eq = simplify(eq)
+                    printeq_log(logs)
+                    print()
+            elif command.split(" ")[0] == "diff":
+                eq = diff(eq, parse(command.split(" ")[1]).name)
+            else:
+                eq = parse(command)
+            eq = copy.deepcopy(eq)
+            printeq(eq)
+        except:
+            eq = copy.deepcopy(orig)
+            print("error")

mathai/diff.py

@@ -1,65 +1,65 @@
-from .simplify import solve
-from .base import *
-
-def diff(equation, var="v_0"):
-    def diffeq(eq):
-        eq = solve(eq)
-        if "v_" not in str_form(eq):
-            return tree_form("d_0")
-        if eq.name == "f_add":
-            add = tree_form("d_0")
-            for child in eq.children:
-                add += diffeq(child)
-            return add
-        elif eq.name == "f_abs":
-            return diffeq(eq.children[0])*eq.children[0]/eq
-        elif eq.name == "f_pow" and eq.children[0].name == "s_e":
-            return diffeq(eq.children[1])*eq
-        elif eq.name == "f_tan":
-            return diffeq(eq.children[0])/(eq.children[0].fx("cos")*eq.children[0].fx("cos"))
-        elif eq.name == "f_log":
-            return diffeq(eq.children[0])*(tree_form("d_1")/eq.children[0])
-        elif eq.name == "f_arcsin":
-            return diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
-        elif eq.name == "f_arccos":
-            return tree_form("d_-1")*diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
-        elif eq.name == "f_arctan":
-            return diffeq(eq.children[0])/(tree_form("d_1")+eq.children[0]*eq.children[0])
-        elif eq.name == "f_pow" and "v_" in str_form(eq.children[1]):
-            a, b = eq.children
-            return a**b * ((b/a) * diffeq(a) + a.fx("log") * diffeq(b))
-        elif eq.name == "f_mul":
-            add = tree_form("d_0")
-            for i in range(len(eq.children)):
-                tmp = eq.children.pop(i)
-                if len(eq.children)==1:
-                    eq2 = eq.children[0]
-                else:
-                    eq2 = eq
-                add += diffeq(tmp)*eq2
-                eq.children.insert(i, tmp)
-            return add
-        elif eq.name == "f_sin":
-            eq.name = "f_cos"
-            return diffeq(eq.children[0])*eq
-        elif eq.name == "f_cos":
-            eq.name = "f_sin"
-            return tree_form("d_-1")*diffeq(eq.children[0])*eq
-        elif eq.name[:2] == "v_":
-            return TreeNode("f_dif", [eq])
-        elif eq.name == "f_pow" and "v_" not in str_form(eq.children[1]):
-            base, power = eq.children
-            dbase = diffeq(base)
-            b1 = power - tree_form("d_1")
-            bab1 = TreeNode("f_pow", [base, b1])
-            return power * bab1 * dbase
-        return eq.fx("dif")
-    def helper(equation, var="v_0"):
-        if equation.name == "f_dif":
-            if equation.children[0].name == var:
-                return tree_form("d_1")
-            return tree_form("d_0")
-        return TreeNode(equation.name, [helper(child, var) for child in equation.children])
-    equation = diffeq(equation)
-    equation = helper(equation, var)
-    return solve(equation)
+from .simplify import solve
+from .base import *
+
+def diff(equation, var="v_0"):
+    def diffeq(eq):
+        eq = solve(eq)
+        if "v_" not in str_form(eq):
+            return tree_form("d_0")
+        if eq.name == "f_add":
+            add = tree_form("d_0")
+            for child in eq.children:
+                add += diffeq(child)
+            return add
+        elif eq.name == "f_abs":
+            return diffeq(eq.children[0])*eq.children[0]/eq
+        elif eq.name == "f_pow" and eq.children[0].name == "s_e":
+            return diffeq(eq.children[1])*eq
+        elif eq.name == "f_tan":
+            return diffeq(eq.children[0])/(eq.children[0].fx("cos")*eq.children[0].fx("cos"))
+        elif eq.name == "f_log":
+            return diffeq(eq.children[0])*(tree_form("d_1")/eq.children[0])
+        elif eq.name == "f_arcsin":
+            return diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
+        elif eq.name == "f_arccos":
+            return tree_form("d_-1")*diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
+        elif eq.name == "f_arctan":
+            return diffeq(eq.children[0])/(tree_form("d_1")+eq.children[0]*eq.children[0])
+        elif eq.name == "f_pow" and "v_" in str_form(eq.children[1]):
+            a, b = eq.children
+            return a**b * ((b/a) * diffeq(a) + a.fx("log") * diffeq(b))
+        elif eq.name == "f_mul":
+            add = tree_form("d_0")
+            for i in range(len(eq.children)):
+                tmp = eq.children.pop(i)
+                if len(eq.children)==1:
+                    eq2 = eq.children[0]
+                else:
+                    eq2 = eq
+                add += diffeq(tmp)*eq2
+                eq.children.insert(i, tmp)
+            return add
+        elif eq.name == "f_sin":
+            eq.name = "f_cos"
+            return diffeq(eq.children[0])*eq
+        elif eq.name == "f_cos":
+            eq.name = "f_sin"
+            return tree_form("d_-1")*diffeq(eq.children[0])*eq
+        elif eq.name[:2] == "v_":
+            return TreeNode("f_dif", [eq])
+        elif eq.name == "f_pow" and "v_" not in str_form(eq.children[1]):
+            base, power = eq.children
+            dbase = diffeq(base)
+            b1 = power - tree_form("d_1")
+            bab1 = TreeNode("f_pow", [base, b1])
+            return power * bab1 * dbase
+        return eq.fx("dif")
+    def helper(equation, var="v_0"):
+        if equation.name == "f_dif":
+            if equation.children[0].name == var:
+                return tree_form("d_1")
+            return tree_form("d_0")
+        return TreeNode(equation.name, [helper(child, var) for child in equation.children])
+    equation = diffeq(equation)
+    equation = helper(equation, var)
+    return solve(equation)

mathai/expand.py

@@ -1,58 +1,58 @@
-
-import itertools
-from .base import *
-from .simplify import solve, simplify
-
-def expand(eq):
-    if eq is None:
-        return None
-    if eq.name == "f_mul" or eq.name == "f_pow":
-        if eq.name == "f_pow":
-            eq = TreeNode("f_pow", [eq]) 
-        ac = []
-        addchild = []
-        for child in eq.children:
-            tmp5 = [solve(x) for x in factor_generation(child)]
-            ac += tmp5
-        tmp3 = []
-        for child in ac:
-            tmp2 = []
-            if child.name == "f_add":
-                if child.children != []:
-                    for child2 in child.children:
-                        tmp2.append(child2)
-                else:
-                    tmp2 = [child]
-            else:
-                tmp3.append(child)
-            if tmp2 != []:
-                addchild.append(tmp2)
-        tmp4 = 1
-        for item in tmp3:
-            tmp4 = tmp4 * item
-        addchild.append([tmp4])
-        def flatten(lst):
-            flat_list = []
-            for item in lst:
-                if isinstance(item, list) and item == []:
-                    continue
-                if isinstance(item, list):
-                    flat_list.extend(flatten(item))
-                else:
-                    flat_list.append(item)
-            return flat_list
-        
-        if isinstance(addchild, list) and len(flatten(addchild))>0:
-            add= 0
-            for item in itertools.product(*addchild):
-                mul = 1
-                for item2 in item:
-                    mul = mul * item2
-                    mul = simplify(mul)
-                add = add + mul
-                add = simplify(add)
-            eq = add
-        eq = simplify(eq)
-        
-    return TreeNode(eq.name, [expand(child) for child in eq.children])
-
+
+import itertools
+from .base import *
+from .simplify import solve, simplify
+
+def expand(eq):
+    if eq is None:
+        return None
+    if eq.name == "f_mul" or eq.name == "f_pow":
+        if eq.name == "f_pow":
+            eq = TreeNode("f_pow", [eq]) 
+        ac = []
+        addchild = []
+        for child in eq.children:
+            tmp5 = [solve(x) for x in factor_generation(child)]
+            ac += tmp5
+        tmp3 = []
+        for child in ac:
+            tmp2 = []
+            if child.name == "f_add":
+                if child.children != []:
+                    for child2 in child.children:
+                        tmp2.append(child2)
+                else:
+                    tmp2 = [child]
+            else:
+                tmp3.append(child)
+            if tmp2 != []:
+                addchild.append(tmp2)
+        tmp4 = 1
+        for item in tmp3:
+            tmp4 = tmp4 * item
+        addchild.append([tmp4])
+        def flatten(lst):
+            flat_list = []
+            for item in lst:
+                if isinstance(item, list) and item == []:
+                    continue
+                if isinstance(item, list):
+                    flat_list.extend(flatten(item))
+                else:
+                    flat_list.append(item)
+            return flat_list
+        
+        if isinstance(addchild, list) and len(flatten(addchild))>0:
+            add= 0
+            for item in itertools.product(*addchild):
+                mul = 1
+                for item2 in item:
+                    mul = mul * item2
+                    mul = simplify(mul)
+                add = add + mul
+                add = simplify(add)
+            eq = add
+        eq = simplify(eq)
+        
+    return TreeNode(eq.name, [expand(child) for child in eq.children])
+