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

mathai/__init__.py

@@ -1,10 +1,15 @@
+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 .printeq import printeq, printeq_str
 
-from .simplify import solve, simplify, solve2
+from .simplify import simplify
 
 from .integrate import ref as integrate_save
 from .integrate import integrate_subs_main as integrate_subs
@@ -19,7 +24,9 @@ from .integrate import integrate_formula
 from .diff import diff
 
 from .factor import factor as factor1
-from .factor import factor2
+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
@@ -28,19 +35,19 @@ from .inverse import inverse
 
 from .trig import trig0, trig1, trig2, trig3, trig4
 
-from .logic import logic0, logic1, logic2, logic3
+from .logic import logic0, logic1, logic2, logic3, logic_n
 
-from .apart import apart
+from .apart import apart, apart2
 
-from .console import console
+from .limit import limit1, limit2, limit0, limit3
 
-from .limit import limit
+from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt, prepare
+from .bivariate_inequality import inequality_solve
 
-from .search import dfs_simplify as search0
-
-from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
+from .matrix import matrix_solve
 
 from .base import *
 
 from .tool import enclose_const
-
+from .tool import poly_simplify
+from .tool import longdiv

mathai/apart.py

@@ -1,20 +1,28 @@
 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 .tool import poly, enclose_const
+from .factor import factor2
+from .tool import poly, enclose_const, longdiv
 
-def _apart(eq, v="v_0"):
+def _apart(eq, v=None):
     
+    if v is None:
+        if len(vlist(eq)) == 0:
+            return eq
+        v = vlist(eq)[0]
     origv = vlist(eq)
-    eq = simplify(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
@@ -42,8 +50,9 @@ def _apart(eq, v="v_0"):
     s = []
     facd = [simplify(x) for x in factor_generation(simplify(d))]
     
-     
-    facd2 = remove_duplicates_custom(facd, lambda m, n: simplify(m-n) == tree_form("d_0"))
+    
+    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)
@@ -55,9 +64,10 @@ def _apart(eq, v="v_0"):
         g = countfac(facd, item)
         for n in range(int(g.name[2:])):
             n = n+1
-            if n > 2:
+            if n > 3:
                 return eq
             n = tree_form("d_"+str(n))
+            
             l = len(poly(item, v))
             if l == 3:
                 a = alloclst.pop(0)
@@ -81,6 +91,7 @@ def _apart(eq, v="v_0"):
                     dem.append(item**n)
                     s.append(a/item**n)
             else:
+                
                 return eq
     final3 = summation(s)
     
@@ -89,9 +100,9 @@ def _apart(eq, v="v_0"):
     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)
@@ -101,13 +112,31 @@ def _apart(eq, v="v_0"):
     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]))
-    return simplify(final3)
+    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)
-    
-    eq = _apart(eq)
-    return fx(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

@@ -1,24 +1,67 @@
 import copy
 from fractions import Fraction
+def use(eq):
+    return TreeNode(eq.name, [use(child) for child in eq.children])
+def use2(eq):
+    return use(tree_form(str_form(eq).replace("f_wmul", "f_mul")))
+def contains_list_or_neg(node):
+    stack = [node]
+    while stack:
+        n = stack.pop()
+        if n.name == "f_list" or n.name.startswith("v_-"):
+            return True
+        stack.extend(n.children)
+    return False
 
 class TreeNode:
-    def __init__(self, name, children=[]):
-        
-        children = [child.copy_tree() for child in children]
+    matmul = None
+    
+    def __init__(self, name, children=None):
+        if children is None:
+            children = []
+
+        # copy once
+        children = copy.deepcopy(children)
         self.name = name
-        if name in ["f_add", "f_mul"]:
-            self.children = sorted(children, key=lambda x: str_form(x))
+
+        if name == "f_add" or (name == "f_mul" and TreeNode.matmul is None):
+            keyed = [(str_form(c), c) for c in children]
+            self.children = [c for _, c in sorted(keyed)]
+
+        elif name == "f_mul" and TreeNode.matmul == False:
+            sortable = []
+            fixed = []
+            for c in children:
+                if not contains_list_or_neg(c):
+                    sortable.append(c)
+                else:
+                    fixed.append(c)
+                    
+            if len(sortable) > 1:
+                sortable = TreeNode("f_dmul", list(sorted(sortable, key=lambda x: str_form(x))))
+                sortable.name = "f_mul"
+                
+            elif len(sortable) == 1:
+                sortable = sortable[0]
+                
+            if isinstance(sortable, TreeNode):
+                fixed.append(sortable)
+            if len(fixed) > 1:
+                self.name = "f_wmul"
+            elif len(fixed) == 1:
+                self.name = fixed[0].name
+                fixed = fixed[0].children
+                
+                
+            self.children = fixed
         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 copy_tree(self):
+        return copy.deepcopy(self)
     def __repr__(self):
         return string_equation(str_form(self))
 
@@ -126,11 +169,51 @@ def remove_duplicates_custom(lst, rcustom):
         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):
@@ -140,6 +223,8 @@ def frac(eq):
         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):
@@ -150,23 +235,27 @@ def frac(eq):
     if eq.name == "f_pow":
         a = frac(eq.children[0])
         b = frac(eq.children[1])
-        if isinstance(a, Fraction) and isinstance(b, Fraction) and b.denominator==1:
-            if a == 0 and b <= 0:
-                return None
-            return a**b
-        else:
+        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])
+        tmp = TreeNode("f_mul", [])
+        tmp.children.append(eq)
+        eq = tmp
     if eq.name == "f_mul":
         for child in eq.children:
             if child.name == "f_pow":
-                if child.children[0].name[:2] == "s_":
-                    output.append(child)
-                    continue
                 if child.children[1].name[:2] != "d_":
                     output.append(child)
                     continue
@@ -174,7 +263,10 @@ def factor_generation(eq):
                     n = int(child.children[1].name[2:])
                     if n < 0:
                         for i in range(-n):
-                            output.append(child.children[0]**-1)
+                            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])
@@ -205,11 +297,13 @@ def compute(eq):
     # 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":
+    elif eq.name in ["f_wmul", "f_mul"]:
         result = 1.0
         for v in values:
             result *= v
@@ -241,16 +335,22 @@ def num_dem(equation):
     num = tree_form("d_1")
     den = tree_form("d_1")
     for item in factor_generation(equation):
-        
-        t = item
-        if t.name == "f_pow" and "v_" not in str_form(t.children[1]) and compute(t.children[1]) < 0:
-            
-            den = den*item
+        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, tree_form("d_1")/den]
+    return num, den
+
 def summation(lst):
-    if lst == []:
+    if len(lst) == 0:
         return tree_form("d_0")
     s = lst[0]
     for item in lst[1:]:
@@ -270,28 +370,31 @@ def product(lst):
     for item in lst[1:]:
         s *= item
     return s
-def flatten_tree(node):
+def flatten_tree(node, add=[]):
     if not node.children:
         return node
-    if node.name in ("f_add", "f_mul", "f_and", "f_or"):
+    ad = []
+    if node.name in ["f_add", "f_mul", "f_and", "f_or", "f_wmul"]:
         merged_children = []
         for child in node.children:
-            flattened_child = flatten_tree(child)
+            flattened_child = flatten_tree(child, add)
             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]
+        node.children = [flatten_tree(child, add) for child in node.children]
         return node
 def dowhile(eq, fx):
+    if eq is None:
+        return None
     while True:
-        orig = eq.copy_tree()
+        orig = copy.deepcopy(eq)
         eq2 = fx(eq)
         if eq2 is None:
             return None
-        eq = eq2.copy_tree()
+        eq = copy.deepcopy(eq2)
         if eq == orig:
             return orig
 def tree_form(tabbed_strings):
@@ -325,9 +428,9 @@ def string_equation_helper(equation_tree):
     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)]+["subs", "try", "ref", "integrate", "exist", "forall", "sum2", "int", "pdif", "dif", "A", "B", "C", "covariance", "sum"]:
+    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": "?"}
+    sign = {"f_not":"~", "f_wadd":"+", "f_wmul":"*", "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():
@@ -335,7 +438,7 @@ def string_equation_helper(equation_tree):
     else:
         k = sign[equation_tree.name]
     for child in equation_tree.children:
-        arr.append(string_equation_helper(child.copy_tree()))
+        arr.append(string_equation_helper(copy.deepcopy(child)))
     outfinal = s + k.join(arr) + ")"+extra
     
     return outfinal.replace("+-", "-")