mathai 0.6.0__py3-none-any.whl

mathai/__init__.py

@@ -0,0 +1,53 @@
+from .ode import diffsolve as ode_solve
+from .ode import diffsolve_sep as ode_shift_term
+
+from .linear import linear_solve, linear_or
+
+from .expand import expand
+
+from .parser import parse
+
+from .printeq import printeq, printeq_log, printeq_str
+
+from .simplify import simplify
+
+from .integrate import ref as integrate_save
+from .integrate import integrate_subs_main as integrate_subs
+from .integrate import byparts as integrate_byparts
+from .integrate import sqint as integrate_fraction
+from .integrate import integrate_summation
+from .integrate import rm_const as integrate_const
+from .integrate import solve_integrate as integrate_clean
+from .integrate import inteq as integrate_recursive
+from .integrate import integrate_formula
+
+from .diff import diff
+
+from .factor import factor as factor1
+from .factor import factor2, factor3
+from .factor import rationalize_sqrt as rationalize
+from .factor import merge_sqrt
+from .factor import factorconst as factor0
+
+from .fraction import fraction
+
+from .inverse import inverse
+
+from .trig import trig0, trig1, trig2, trig3, trig4
+
+from .logic import logic0, logic1, logic2, logic3, logic_n
+
+from .apart import apart, apart2
+
+from .limit import limit1, limit2, limit0, limit3
+
+from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt, prepare
+from .bivariate_inequality import inequality_solve
+
+from .matrix import uncommute
+
+from .base import *
+
+from .tool import enclose_const
+from .tool import poly_simplify
+from .tool import longdiv

mathai/apart.py

@@ -0,0 +1,142 @@
+from .linear import linear_solve
+from .expand import expand
+from .simplify import simplify
+
+from .diff import diff
+from .inverse import inverse
+from .base import *
+import math
+from .factor import factor2
+from .tool import poly, enclose_const, longdiv
+
+def _apart(eq, v=None):
+    
+    if v is None:
+        if len(vlist(eq)) == 0:
+            return eq
+        v = vlist(eq)[0]
+    origv = vlist(eq)
+    
+    if eq.name != "f_mul":
+        return eq
+    
+    if any("f_"+item in str_form(eq) for item in "sin cos tan log".split(" ")):
+        return eq
+    
+    def exclude(eq):
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]).denominator != 1:
+            return False
+        if any(not exclude(child) for child in eq.children):
+            return False
+        return True
+    
+    if not exclude(eq):
+        return eq
+    
+    def countfac(lst, eq):
+        count=0
+        for item in lst:
+            if simplify(expand(simplify(eq - item))) == tree_form("d_0"):
+                count += 1
+        return tree_form("d_"+str(count))
+    
+    alloclst = []
+    for i in range(0,26):
+        if "v_"+str(i) not in vlist(eq):
+            alloclst.append(tree_form("v_"+str(i)))
+    
+    nn, d = num_dem(eq)
+    
+    s = []
+    facd = [simplify(x) for x in factor_generation(simplify(d))]
+    
+    
+    facd2 = remove_duplicates_custom(facd, lambda m, n: simplify(expand(simplify(m-n))) == tree_form("d_0"))
+    
+    if len(facd2) == 1:
+        return eq
+    x = tree_form(v)
+    num = []
+    dem = []
+    
+    for item in facd2:
+        
+        g = countfac(facd, item)
+        for n in range(int(g.name[2:])):
+            n = n+1
+            if n > 3:
+                return eq
+            n = tree_form("d_"+str(n))
+            
+            l = len(poly(item, v))
+            if l == 3:
+                a = alloclst.pop(0)
+                b = alloclst.pop(0)
+                if n == tree_form("d_1"):
+                    num.append(a*x+ b)
+                    dem.append(item)
+                    s.append((a*x+ b)/item)
+                else:
+                    num.append(a*x+ b)
+                    dem.append(item**n)
+                    s.append((a*x+ b)/item**n)
+            elif l == 2:
+                a = alloclst.pop(0)
+                if n == tree_form("d_1"):
+                    num.append(a)
+                    dem.append(item)
+                    s.append(a/item)
+                else:
+                    num.append(a)
+                    dem.append(item**n)
+                    s.append(a/item**n)
+            else:
+                
+                return eq
+    final3 = summation(s)
+    
+    eq2 = simplify(nn*product(dem)/d)
+    
+    final2 = []
+    for i in range(len(num)):
+        final2.append(product([dem[k] for k in range(len(dem)) if i != k])*num[i])
+    
+    final = summation(final2)
+    
+    s = simplify(TreeNode("f_eq", [final-eq2, tree_form("d_0")]))
+    
+    lst = poly(s.children[0], v)
+    
+    lst = [TreeNode("f_eq", [item, tree_form("d_0")]) for item in lst if "v_" in str_form(item)]
+    lst2 = []
+    for item in lst:
+        lst2+=vlist(item)
+    origv = list(set(lst2)-set(origv))
+    
+    out = linear_solve(TreeNode("f_and", lst), [tree_form(item) for item in origv])
+    for item in out.children:
+        
+        final3 = replace(final3, tree_form(list(set(vlist(item))&set(origv))[0]), inverse(item.children[0], list(set(vlist(item))&set(origv))[0]))
+    final4 = simplify(final3)
+    
+    return final4
+def apart2(eq):
+    if eq.name == "f_mul":
+        
+        a, b = num_dem(eq)
+        
+        tmp = longdiv(a, b, 2, 1)
+        
+        if tmp is not None:
+            return simplify(tmp[0]+tmp[1]/b)
+    return TreeNode(eq.name, [apart2(child) for child in eq.children])
+def apart(eq):
+    eq = factor2(simplify(eq))
+    eq, fx = enclose_const(eq)
+    def helper(eq):
+        eq2 = _apart(eq)
+        if eq != eq2:
+            return eq2
+       
+        return TreeNode(eq.name, [helper(child) for child in eq.children])
+    return fx(helper(eq))

mathai/base.py

@@ -0,0 +1,419 @@
+import copy
+from fractions import Fraction
+
+class TreeNode:
+    def __init__(self, name, children=[]):
+        
+        children = [child.copy_tree() for child in children]
+        self.name = name
+        if name in ["f_add", "f_mul"]:
+            self.children = sorted(children, key=lambda x: str_form(x))
+        else:
+            self.children = children
+
+    def fx(self, fxname):
+        return TreeNode("f_" + fxname, [self])
+    def copy_tree(node):
+        if node is None:
+            return None
+
+        return tree_form(str_form(node))
+
+    def __repr__(self):
+        return string_equation(str_form(self))
+
+    def __eq__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        elif not isinstance(other, TreeNode):
+            return NotImplemented
+        return str_form(self) == str_form(other)
+
+    def __add__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return TreeNode("f_add", [self, other])
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __mul__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return TreeNode("f_mul", [self, other])
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __sub__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return self + (tree_form("d_-1") * other)
+
+    def __rsub__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return other + (tree_form("d_-1") * self)
+
+    def __pow__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return TreeNode("f_pow", [self, other])
+
+    def __rpow__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return TreeNode("f_pow", [other, self])
+
+    def __truediv__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return self * (other ** tree_form("d_-1"))
+
+    def __rtruediv__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return other * (self ** tree_form("d_-1"))
+
+    def __and__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return TreeNode("f_and", [self, other])
+
+    def __rand__(self, other):
+        return self.__and__(other)
+
+    def __or__(self, other):
+        if isinstance(other, int):
+            other = tree_form("d_" + str(other))
+        return TreeNode("f_or", [self, other])
+
+    def __ror__(self, other):
+        return self.__or__(other)
+
+    def __neg__(self):
+        return tree_form("d_-1") * self
+
+    def __hash__(self):
+        return hash(str_form(self))
+
+def str_form(node):
+    def recursive_str(node, depth=0):
+        result = "{}{}".format(' ' * depth, node.name)
+        for child in node.children:
+            result += "\n" + recursive_str(child, depth + 1)
+        return result
+    if not isinstance(node, TreeNode):
+        return "d_"+str(node)
+    return recursive_str(node)
+def replace(equation, find, r):
+  if str_form(equation) == str_form(find):
+    return r
+  col = TreeNode(equation.name, [])
+  for child in equation.children:
+    col.children.append(replace(child, find, r))
+  return col
+
+def contain(equation, what):
+    if equation == what:
+        return True
+    if equation.children == []:
+        return False
+    return any(contain(child, what) for child in equation.children)
+def remove_duplicates_custom(lst, rcustom):
+    result = []
+    for item in lst:
+        if not any(rcustom(item, x) for x in result):
+            result.append(item)
+    return result
+def frac_to_tree(f):
+    if isinstance(f, int):
+        f = Fraction(f)
+    if f.numerator == 0:
+        return tree_form("d_0")
+    if f.numerator == 1:
+        if f.denominator == 1:
+            return tree_form("d_1")
+        return tree_form("d_"+str(f.denominator))**tree_form("d_-1")
+    if f.denominator == 1:
+        return tree_form("d_"+str(f.numerator))
+    else:
+        return tree_form("d_"+str(f.numerator))/tree_form("d_"+str(f.denominator))
+def perfect_root(n, r):
+    if r <= 0 or (n < 0 and r % 2 == 0):
+        return False, None
+
+    lo = 0
+    hi = n if n > 1 else 1
+
+    while lo <= hi:
+        mid = lo + (hi - lo) // 2
+        pow_val = 1
+
+        for _ in range(r):
+            pow_val *= mid
+            if pow_val > n:
+                break
+
+        if pow_val == n:
+            return True, mid
+        elif pow_val < n:
+            lo = mid + 1
+        else:
+            hi = mid - 1
+
+    return False, None
+
+def frac(eq):
+    if eq.name[:2] == "d_":
+        return Fraction(int(eq.name[2:]))
+    if eq.name == "f_add":
+        p = frac(eq.children[0])
+        if p is None:
+            return None
+        for child in eq.children[1:]:
+            tmp = frac(child)
+            if isinstance(tmp, Fraction):
+                p+= tmp
+            else:
+                return None
+        return p
+    if eq.name == "f_mul":
+        p = frac(eq.children[0])
+        if p is None:
+            return None
+        for child in eq.children[1:]:
+            tmp = frac(child)
+            if isinstance(tmp, Fraction):
+                p*= tmp
+            else:
+                return None
+        return p
+    if eq.name == "f_pow":
+        a = frac(eq.children[0])
+        b = frac(eq.children[1])
+        if a is None or b is None:
+            return None
+        if a == 0 and b <= 0:
+            return None
+        if b.denominator == 1:
+            return a ** b.numerator
+        found_c, c = perfect_root(a.numerator, b.denominator)
+        found_d, d = perfect_root(a.denominator, b.denominator)
+        if found_c and found_d:
+            return Fraction(c,d) ** b.numerator
+        return None
+    return None
+def factor_generation(eq):
+    output = []
+    if eq.name != "f_mul":
+        eq = TreeNode("f_mul", [eq])
+    if eq.name == "f_mul":
+        for child in eq.children:
+            if child.name == "f_pow":
+                if child.children[1].name[:2] != "d_":
+                    output.append(child)
+                    continue
+                if frac(child.children[1]) is not None and frac(child.children[1]).denominator == 1:
+                    n = int(child.children[1].name[2:])
+                    if n < 0:
+                        for i in range(-n):
+                            out = factor_generation(child.children[0])
+                            out = [x**-1 for x in out]
+                            output += out
+                            #output.append(child.children[0]**-1)
+                    else:
+                        for i in range(n):
+                            output.append(child.children[0])
+                else:
+                    output.append(child)
+            else:
+                output.append(child)
+                
+    return output
+import math
+
+def compute(eq):
+    # Base case: leaf node
+    if eq.children == []:
+        if eq.name == "s_e":
+            return math.e
+        elif eq.name == "s_pi":
+            return math.pi
+        elif eq.name.startswith("d_"):
+            return float(eq.name[2:])
+        else:
+            return None
+
+    # Recursive case: compute child values
+    values = [compute(child) for child in eq.children]
+    if None in values:
+        return None
+    # Evaluate based on node type
+    if eq.name == "f_add":
+        return sum(values)
+    elif eq.name == "f_abs":
+        return math.fabs(values[0])
+    elif eq.name == "f_sub":
+        return values[0] - values[1]
+    elif eq.name == "f_rad":
+        return values[0] * math.pi / 180
+    elif eq.name == "f_mul":
+        result = 1.0
+        for v in values:
+            result *= v
+        return result
+    elif eq.name == "f_neg":
+        return -values[0]
+    elif eq.name == "f_div":
+        return values[0] / values[1]
+    elif eq.name == "f_pow":
+        return values[0] ** values[1]
+    elif eq.name == "f_sin":
+        return math.sin(values[0])
+    elif eq.name == "f_cos":
+        return math.cos(values[0])
+    elif eq.name == "f_tan":
+        return math.tan(values[0])
+    elif eq.name == "f_arcsin":
+        return math.asin(values[0])
+    elif eq.name == "f_arccos":
+        return math.acos(values[0])
+    elif eq.name == "f_arctan":
+        return math.atan(values[0])
+    elif eq.name == "f_log":
+        return math.log(values[0])
+    else:
+        return None
+
+def num_dem(equation):
+    num = tree_form("d_1")
+    den = tree_form("d_1")
+    for item in factor_generation(equation):
+        if item.name == "f_pow":
+            c = frac(item.children[1])
+            if c is not None and c < 0:
+                t = frac_to_tree(-c)
+                if t == tree_form("d_1"):
+                    den = den * item.children[0]
+                else:
+                    den = den * item.children[0]**t
+            else:
+                den = den * item
+        else:
+            num = num*item
+    return num, den
+
+def summation(lst):
+    if len(lst) == 0:
+        return tree_form("d_0")
+    s = lst[0]
+    for item in lst[1:]:
+        s += item
+    return s
+def vlist(eq):
+    out = []
+    if eq.name[:2] == "v_":
+        out.append(eq.name)
+    for child in eq.children:
+        out += vlist(child)
+    return sorted(list(set(out)), key=lambda x: int(x[2:]))
+def product(lst):
+    if lst == []:
+        return tree_form("d_1")
+    s = lst[0]
+    for item in lst[1:]:
+        s *= item
+    return s
+def flatten_tree(node):
+    if not node.children:
+        return node
+    if node.name in ("f_add", "f_mul", "f_and", "f_or"):
+        merged_children = []
+        for child in node.children:
+            flattened_child = flatten_tree(child)
+            if flattened_child.name == node.name:
+                merged_children.extend(flattened_child.children)
+            else:
+                merged_children.append(flattened_child)
+        return TreeNode(node.name, merged_children)
+    else:
+        node.children = [flatten_tree(child) for child in node.children]
+        return node
+def dowhile(eq, fx):
+    if eq is None:
+        return None
+    while True:
+        orig = eq.copy_tree()
+        eq2 = fx(eq)
+        if eq2 is None:
+            return None
+        eq = eq2.copy_tree()
+        if eq == orig:
+            return orig
+def tree_form(tabbed_strings):
+    lines = tabbed_strings.split("\n")
+    root = TreeNode("Root")
+    current_level_nodes = {0: root}
+    stack = [root]
+    for line in lines:
+        level = line.count(' ')
+        node_name = line.strip()
+        node = TreeNode(node_name)
+        while len(stack) > level + 1:
+            stack.pop()
+        parent_node = stack[-1]
+        parent_node.children.append(node)
+        current_level_nodes[level] = node
+        stack.append(node)
+    return root.children[0]
+def string_equation_helper(equation_tree):
+    if equation_tree.children == []:
+        if equation_tree.name[:2]=="g_":
+            return '"'+equation_tree.name[2:]+'"'
+        return equation_tree.name
+    extra = ""
+    if equation_tree.name == "f_neg":
+        return "-"+string_equation_helper(equation_tree.children[0])
+    if equation_tree.name == "f_not":
+        return "~"+string_equation_helper(equation_tree.children[0])
+    if equation_tree.name == "f_list":
+        return "["+",".join([string_equation_helper(child) for child in equation_tree.children])+"]"
+    if equation_tree.name == "f_index":
+        return string_equation_helper(equation_tree.children[0])+"["+",".join([string_equation_helper(child) for child in equation_tree.children[1:]])+"]"
+    s = "(" 
+    if len(equation_tree.children) == 1 or equation_tree.name[2:] in [chr(ord("A")+i) for i in range(26)]+["limitpinf", "subs", "try", "ref","limit", "integrate", "exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
+        s = equation_tree.name[2:] + s
+    sign = {"f_not":"~", "f_addw":"+", "f_mulw":"*", "f_intersection":"&", "f_union":"|", "f_sum2":",", "f_exist":",", "f_forall":",", "f_sum":",","f_covariance": ",", "f_B":",", "f_imply":"->", "f_ge":">=", "f_le":"<=", "f_gt":">", "f_lt":"<", "f_cosec":"?" , "f_equiv": "<->", "f_sec":"?", "f_cot": "?", "f_dot": ".", "f_circumcenter":"?", "f_transpose":"?", "f_exp":"?", "f_abs":"?", "f_log":"?", "f_and":"&", "f_or":"|", "f_sub":"-", "f_neg":"?", "f_inv":"?", "f_add": "+", "f_mul": "*", "f_pow": "^", "f_poly": ",", "f_div": "/", "f_sub": "-", "f_dif": ",", "f_sin": "?", "f_cos": "?", "f_tan": "?", "f_eq": "=", "f_sqrt": "?"}
+    arr = []
+    k = None
+    if equation_tree.name not in sign.keys():
+        k = ","
+    else:
+        k = sign[equation_tree.name]
+    for child in equation_tree.children:
+        arr.append(string_equation_helper(child.copy_tree()))
+    outfinal = s + k.join(arr) + ")"+extra
+    
+    return outfinal.replace("+-", "-")
+def string_equation(eq):
+    alpha = ["x", "y", "z"]+[chr(x+ord("a")) for x in range(0,23)]
+    beta = [chr(x+ord("A")) for x in range(0,26)]
+    eq = tree_form(eq)
+    
+    for i, letter in enumerate(alpha):
+        eq = replace(eq, tree_form("v_"+str(i)), tree_form(letter))
+    for i, letter in enumerate(beta):
+        eq = replace(eq, tree_form("v_-"+str(i+1)), tree_form(letter))
+    for i in range(100, 150):
+        eq = replace(eq, tree_form("v_"+str(i)), tree_form("c"+str(i-100)))
+    eq = str_form(eq)
+    
+    eq = eq.replace("d_", "")
+    eq = eq.replace("s_", "")
+    eq = eq.replace("v_", "")
+    eq = eq.replace("'", "")
+    outfinal = string_equation_helper(tree_form(eq))
+    if outfinal[0] == "(" and outfinal[-1] == ")":
+        return outfinal[1:-1]
+    return outfinal