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

mathai/inverse.py

@@ -1,65 +1,65 @@
-from .base import *
-from .simplify import solve
-from .expand import expand
-def inverse(rhs,term, sign=None):
-    term = tree_form(term)
-    lhs = tree_form("d_0")
-    count = 15
-    
-    while not rhs==term:
-        if rhs.name == "f_add":
-            if all(term in factor_generation(child) for child in rhs.children):
-                newrhs = solve(expand(rhs*term**-1))
-                if not contain(newrhs, term):
-                    rhs = term * newrhs
-            else:
-                for i in range(len(rhs.children)-1,-1,-1):
-                    if not contain(rhs.children[i], term):
-                        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], term):
-                    lhs = lhs * rhs.children[i]**-1
-                    if sign is not None:
-                        if "v_" in str_form(rhs.children[i]):
-                            return None
-                        if compute(rhs.children[i]**-1) < 0:
-                            sign = not sign
-                    
-                    rhs.children.pop(i)
-        elif rhs.name == "f_pow" and contain(rhs.children[0], term):
-            lhs = lhs ** (tree_form("d_1")/rhs.children[1])
-            rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_sin" and contain(rhs.children[0], term):
-            lhs = lhs.fx("arcsin")
-            rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_arcsin" and contain(rhs.children[0], term):
-            lhs = lhs.fx("sin")
-            rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_arccos" and contain(rhs.children[0], term):
-            lhs = lhs.fx("cos")
-            rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_cos" and contain(rhs.children[0], term):
-            lhs = lhs.fx("arccos")
-            rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_log" and contain(rhs.children[0], term):
-            lhs = tree_form("s_e")**lhs
-            rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_pow" and rhs.children[0].name == "s_e" and contain(rhs.children[1], term):
-            lhs = lhs.fx("log")
-            rhs = copy.deepcopy(rhs.children[1].fx("log"))
-        elif rhs.name == "f_tan" and contain(rhs.children[0], term):
-            lhs = lhs.fx("arctan")
-            rhs = copy.deepcopy(rhs.children[0])
-        elif rhs.name == "f_arctan" and contain(rhs.children[0], term):
-            lhs = lhs.fx("tan")
-            rhs = copy.deepcopy(rhs.children[0])
-        if len(rhs.children) == 1:
-            rhs = rhs.children[0]
-        count -= 1
-        if count == 0:
-            return None
-    if sign is None:
-        return solve(lhs)
-    return solve(lhs), sign
+from .base import *
+from .simplify import solve
+from .expand import expand
+def inverse(rhs,term, sign=None):
+    term = tree_form(term)
+    lhs = tree_form("d_0")
+    count = 15
+    
+    while not rhs==term:
+        if rhs.name == "f_add":
+            if all(term in factor_generation(child) for child in rhs.children):
+                newrhs = solve(expand(rhs*term**-1))
+                if not contain(newrhs, term):
+                    rhs = term * newrhs
+            else:
+                for i in range(len(rhs.children)-1,-1,-1):
+                    if not contain(rhs.children[i], term):
+                        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], term):
+                    lhs = lhs * rhs.children[i]**-1
+                    if sign is not None:
+                        if "v_" in str_form(rhs.children[i]):
+                            return None
+                        if compute(rhs.children[i]**-1) < 0:
+                            sign = not sign
+                    
+                    rhs.children.pop(i)
+        elif rhs.name == "f_pow" and contain(rhs.children[0], term):
+            lhs = lhs ** (tree_form("d_1")/rhs.children[1])
+            rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_sin" and contain(rhs.children[0], term):
+            lhs = lhs.fx("arcsin")
+            rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_arcsin" and contain(rhs.children[0], term):
+            lhs = lhs.fx("sin")
+            rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_arccos" and contain(rhs.children[0], term):
+            lhs = lhs.fx("cos")
+            rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_cos" and contain(rhs.children[0], term):
+            lhs = lhs.fx("arccos")
+            rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_log" and contain(rhs.children[0], term):
+            lhs = tree_form("s_e")**lhs
+            rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_pow" and rhs.children[0].name == "s_e" and contain(rhs.children[1], term):
+            lhs = lhs.fx("log")
+            rhs = copy.deepcopy(rhs.children[1].fx("log"))
+        elif rhs.name == "f_tan" and contain(rhs.children[0], term):
+            lhs = lhs.fx("arctan")
+            rhs = copy.deepcopy(rhs.children[0])
+        elif rhs.name == "f_arctan" and contain(rhs.children[0], term):
+            lhs = lhs.fx("tan")
+            rhs = copy.deepcopy(rhs.children[0])
+        if len(rhs.children) == 1:
+            rhs = rhs.children[0]
+        count -= 1
+        if count == 0:
+            return None
+    if sign is None:
+        return solve(lhs)
+    return solve(lhs), sign

mathai/limit.py

@@ -1,130 +1,130 @@
-from .structure import structure
-from .base import *
-from .parser import parse
-from .simplify import simplify, solve
-from .expand import expand
-from .diff import diff
-from .trig import trig0
-from .fraction import fraction
-from .printeq import printeq_str
-tab=0
-def substitute_val(eq, val, var="v_0"):
-    eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
-    return eq
-
-def subslimit(equation, var):
-    equation2 = trig0(replace(equation, var, tree_form("d_0")))
-    try:
-        tmp = simplify(equation2)
-        return simplify(expand(tmp))
-    except:
-        return None
-    
-def check(num, den, var):
-    n, d = None, None
-    
-    n, d = (dowhile(replace(e, tree_form(var), tree_form("d_0")), lambda x: trig0(simplify(x))) for e in (num, den))
-
-    if n is None or d is None:
-        return False
-    if n == 0 and d == 0: return True
-    if d != 0:
-        return simplify(n/d)
-    return False
-def lhospital(num, den, steps,var):
-    logs = []
-    
-    out = check(num, den, var)
-    if isinstance(out, TreeNode):
-        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
-def lhospital2(eq, var):
-    eq=  simplify(eq)
-    if eq is None:
-        return None
-    if not contain(eq, tree_form(var)):
-        return eq,[]
-    num, dem = [simplify(item) for item in num_dem(eq)]
-    if num is None or dem is None:
-        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
-                
-        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))
-
-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
-    
-    equation, tmp = 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
+from .structure import structure
+from .base import *
+from .parser import parse
+from .simplify import simplify, solve
+from .expand import expand
+from .diff import diff
+from .trig import trig0
+from .fraction import fraction
+from .printeq import printeq_str
+tab=0
+def substitute_val(eq, val, var="v_0"):
+    eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
+    return eq
+
+def subslimit(equation, var):
+    equation2 = trig0(replace(equation, var, tree_form("d_0")))
+    try:
+        tmp = simplify(equation2)
+        return simplify(expand(tmp))
+    except:
+        return None
+    
+def check(num, den, var):
+    n, d = None, None
+    
+    n, d = (dowhile(replace(e, tree_form(var), tree_form("d_0")), lambda x: trig0(simplify(x))) for e in (num, den))
+
+    if n is None or d is None:
+        return False
+    if n == 0 and d == 0: return True
+    if d != 0:
+        return simplify(n/d)
+    return False
+def lhospital(num, den, steps,var):
+    logs = []
+    
+    out = check(num, den, var)
+    if isinstance(out, TreeNode):
+        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
+def lhospital2(eq, var):
+    eq=  simplify(eq)
+    if eq is None:
+        return None
+    if not contain(eq, tree_form(var)):
+        return eq,[]
+    num, dem = [simplify(item) for item in num_dem(eq)]
+    if num is None or dem is None:
+        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
+                
+        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))
+
+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
+    
+    equation, tmp = 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