mathai 0.4.8__py3-none-any.whl → 0.7.2__py3-none-any.whl

mathai/__init__.py

@@ -1,15 +1,15 @@
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 
-from .linear import linear_solve
+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
@@ -24,7 +24,7 @@ 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
@@ -35,15 +35,16 @@ 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, 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 .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
+from .matrix import matrix_solve
 
 from .base import *
 

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,6 +169,44 @@ 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:]))
@@ -154,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
@@ -178,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])
@@ -209,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
@@ -245,14 +335,19 @@ 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 len(lst) == 0:
@@ -276,9 +371,12 @@ def product(lst):
         s *= item
     return s
 def flatten_tree(node):
+    if node is None:
+        return None
     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)
@@ -294,11 +392,11 @@ 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):
@@ -332,9 +430,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():
@@ -342,7 +440,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("+-", "-")

mathai/bivariate_inequality.py

@@ -0,0 +1,317 @@
+import math
+from .linear import linear_or
+from functools import reduce
+import operator
+from .base import *
+from .simplify import simplify
+from .expand import expand
+from .logic import logic0
+
+def shoelace_area(vertices):
+    n = len(vertices)
+    area = 0.0
+    for i in range(n):
+        j = (i + 1) % n
+        area += vertices[i][0] * vertices[j][1]
+        area -= vertices[j][0] * vertices[i][1]
+    return abs(area) / 2.0
+
+def triangle_area(p1, p2, p3):
+    area = 0.0
+    area += p1[0] * (p2[1] - p3[1])
+    area += p2[0] * (p3[1] - p1[1])
+    area += p3[0] * (p1[1] - p2[1])
+    return abs(area) / 2.0
+
+def is_point_inside_polygon(point, vertices):
+    if len(vertices) < 3:
+        return False
+
+    polygon_area = shoelace_area(vertices)
+    
+    total_triangle_area = 0.0
+    n = len(vertices)
+    for i in range(n):
+        j = (i + 1) % n
+        total_triangle_area += triangle_area(point, vertices[i], vertices[j])
+    
+    tolerance = 1e-5
+    return abs(total_triangle_area - polygon_area) < tolerance
+
+def distance_point_to_segment(px, py, x1, y1, x2, y2):
+    dx, dy = x2 - x1, y2 - y1
+    if dx == dy == 0:
+        return ((px - x1)**2 + (py - y1)**2)**0.5
+    t = max(0, min(1, ((px - x1) * dx + (py - y1) * dy) / (dx*dx + dy*dy)))
+    proj_x = x1 + t * dx
+    proj_y = y1 + t * dy
+    return ((px - proj_x)**2 + (py - proj_y)**2)**0.5
+
+def deterministic_middle_point(vertices, grid_resolution=100):
+    xs = [v[0] for v in vertices]
+    ys = [v[1] for v in vertices]
+    xmin, xmax = min(xs), max(xs)
+    ymin, ymax = min(ys), max(ys)
+    
+    best_point = None
+    max_dist = -1
+    
+    for i in range(grid_resolution + 1):
+        for j in range(grid_resolution + 1):
+            px = xmin + (xmax - xmin) * i / grid_resolution
+            py = ymin + (ymax - ymin) * j / grid_resolution
+            if not is_point_inside_polygon((px, py), vertices):
+                continue
+            min_edge_dist = float('inf')
+            n = len(vertices)
+            for k in range(n):
+                x1, y1 = vertices[k]
+                x2, y2 = vertices[(k + 1) % n]
+                d = distance_point_to_segment(px, py, x1, y1, x2, y2)
+                min_edge_dist = min(min_edge_dist, d)
+            if min_edge_dist > max_dist:
+                max_dist = min_edge_dist
+                best_point = (px, py)
+    
+    return best_point
+
+def build(eq):
+    eq = TreeNode("f_or", eq)
+    eq = flatten_tree(eq)
+    orig = eq.copy_tree()
+    def fxhelper3(eq):
+        if eq.name[2:] in "le ge lt gt".split(" "):
+            return TreeNode("f_eq", [child.copy_tree() for child in eq.children])
+        return TreeNode(eq.name, [fxhelper3(child) for child in eq.children])
+    eq = fxhelper3(eq)
+    
+    result = linear_or(eq)
+    
+    if result is None:
+        return None
+    
+    maxnum = tree_form("d_2")
+    if len(result[1]) != 0:
+        maxnum = max([max([simplify(item2.fx("abs")) for item2 in item], key=lambda x: compute(x)) for item in result[1]], key=lambda x: compute(x))
+        maxnum += 1
+        maxnum = simplify(maxnum)
+    eq = flatten_tree(eq | simplify(TreeNode("f_or", [TreeNode("f_eq", [tree_form(item)+maxnum, tree_form("d_0")])|\
+                                                      TreeNode("f_eq", [tree_form(item)-maxnum, tree_form("d_0")]) for item in ["v_0","v_1"]])))
+    result2 = linear_or(eq)
+    if result2 is None:
+        return None
+    
+    point_lst = result2[2]
+
+    def gen(point):
+        nonlocal point_lst
+        out = []
+        for item in point_lst:
+            p = None
+            if point in item:
+                p = item.index(point)
+            else:
+                continue
+            if p < len(item)-1:
+                out.append(item[p+1])
+            if p > 0:
+                out.append(item[p-1])
+        return list(set(out))
+    start = list(range(len(result2[1])))
+    graph= {}
+    for item in start:
+        graph[item] = gen(item)
+
+    points = {}
+    for index, item in enumerate(result2[1]):
+        points[index] = [compute(item2) for item2 in item]
+
+    res = []
+    for index, item in enumerate(result2[1]):
+        if any(simplify(item2.fx("abs")-maxnum)!=0 and abs(compute(item2))>compute(maxnum) for item2 in item):
+            res.append(index)
+            
+    graph = {k: sorted(v) for k, v in graph.items()}
+
+    def dfs(current, parent, path, visited, cycles):
+        path.append(current)
+        visited.add(current)
+        for neighbor in graph[current]:
+            if neighbor == parent:
+                continue
+            if neighbor in visited:
+                idx = path.index(neighbor)
+                cycle = path[idx:]
+                cycles.append(cycle)
+            else:
+                dfs(neighbor, current, path, visited, cycles)
+        path.pop()
+        visited.remove(current)
+
+    cycles = []
+    for start in sorted(graph.keys()):
+        path = []
+        visited = set()
+        dfs(start, -1, path, visited, cycles)
+
+    def normalize(cycle):
+        k = len(cycle)
+        if k < 3:
+            return None
+        candidates = []
+        for direction in [cycle, list(reversed(cycle))]:
+            doubled = direction + direction[:-1]
+            for i in range(k):
+                rot = tuple(doubled[i:i + k])
+                candidates.append(rot)
+        return min(candidates)
+
+    unique = set()
+    for c in cycles:
+        norm = normalize(c)
+        if norm:
+            unique.add(norm)
+
+    cycles = sorted(list(unique), key=lambda x: (len(x), x))
+
+    start = list(range(len(result2[1])))
+    for i in range(len(cycles)-1,-1,-1):
+        if any(item in cycles[i] for item in res) or\
+           any(is_point_inside_polygon([compute(item2) for item2 in list(result2[1][p])], [[compute(item2) for item2 in result2[1][item]] for item in cycles[i]]) for p in list(set(start) - set(cycles[i]))) or\
+           any(len(set(graph[item]) & set(cycles[i]))>2 for item in cycles[i]):
+            cycles.pop(i)
+            
+    point_lst = [index for index, item in enumerate(result2[1]) if item in result[1]]
+
+    border = []
+    for item in start:
+        for item2 in graph[item]:
+            a = result2[1][item]
+            b = result2[1][item2]
+            
+            if a[0] == b[0] and simplify(a[0].fx("abs") - maxnum) == 0:
+                continue
+            if a[1] == b[1] and simplify(a[1].fx("abs") - maxnum) == 0:
+                continue
+            
+            border.append(tuple(sorted([item, item2])))
+
+    line = []
+    for key in graph.keys():
+        for item in list(set(point_lst)&set(graph[key])):
+            line.append(tuple(sorted([item, key])))
+    line = list(set(line+border))
+    point_in = [deterministic_middle_point([[compute(item3) for item3 in result2[1][item2]] for item2 in item]) for item in cycles]
+    def work(eq, point):
+        nonlocal result2
+        if eq.name[:2] == "d_":
+            return float(eq.name[2:])
+        if eq.name in result2[0]:
+            return point[result2[0].index(eq.name)]
+        if eq.name == "f_add":
+            return sum(work(item, point) for item in eq.children)
+        if eq.name == "f_mul":
+            return math.prod(work(item, point) for item in eq.children)
+        if eq.name == "f_sub":
+            return work(eq.children[0], point) - work(eq.children[1], point)
+        return {"eq": lambda a,b: abs(a-b)<0.001, "gt":lambda a,b: False if abs(a-b)<0.001 else a>b, "lt":lambda a,b: False if abs(a-b)<0.001 else a<b}[eq.name[2:]](work(eq.children[0], point), work(eq.children[1], point))
+
+    data = []
+    for index, item in enumerate(result2[2][:-4]):
+        a = tuple([item for item in point_lst if work(orig.children[index], [compute(item2) for item2 in result2[1][item]])])
+        #a = tuple(set(item) & set(point_lst))
+        #b = tuple(set([tuple(sorted([item[i], item[i+1]])) for i in range(len(item)-1)]) & set(line))
+        b = None
+        if orig.children[index] == "f_eq":
+            b = tuple([tuple(item) for item in line if work(orig.children[index], [compute(item2) for item2 in result2[1][item[1]]]) and work(orig.children[index], [compute(item2) for item2 in result2[1][item[0]]])])
+        else:
+            b = tuple([tuple(item) for item in line if work(orig.children[index], [compute(item2) for item2 in result2[1][item[1]]]) or work(orig.children[index], [compute(item2) for item2 in result2[1][item[0]]])])
+        c = tuple([tuple(item) for index2, item in enumerate(cycles) if work(orig.children[index], point_in[index2])])
+        data.append((a,b,c))
+        
+    total = tuple([tuple(point_lst), tuple(line), tuple(cycles)])
+    final = {}
+    for index, item in enumerate(orig.children):
+        final[item] = tuple(data[index])
+    return final, total, result2[1]
+
+def inequality_solve(eq):
+    
+    eq = logic0(eq)
+    element = []
+    def helper(eq):
+        nonlocal element
+        
+        if eq.name[2:] in "le ge lt gt eq".split(" ") and "v_" in str_form(eq):
+            element.append(eq)
+        return TreeNode(eq.name, [helper(child) for child in eq.children])
+    helper(eq)
+    
+    out = build(list(set(element)))
+
+    if out is None:
+        return eq
+    
+    def helper2(eq):
+        nonlocal out
+        if eq == tree_form("s_true"):
+            return [set(item) for item in out[1]]
+        if eq == tree_form("s_false"):
+            return [set(), set(), set()]
+        if eq in out[0].keys():
+            return [set(item) for item in out[0][eq]]
+        if eq.name == "f_or":
+            result = [helper2(child) for child in eq.children]
+            a = []
+            b = []
+            c = []
+            for item in result:
+                a += [item[0]]
+                b += [item[1]]
+                c += [item[2]]
+            x = a[0]
+            for item in a[1:]:
+                x |= item
+            y = b[0]
+            for item in b[1:]:
+                y |= item
+            z = c[0]
+            for item in c[1:]:
+                z |= item
+            return [x, y, z]
+        if eq.name == "f_and":
+            result = [helper2(child) for child in eq.children]
+            a = []
+            b = []
+            c = []
+            for item in result:
+                a += [item[0]]
+                b += [item[1]]
+                c += [item[2]]
+            x = a[0]
+            for item in a[1:]:
+                x &= item
+            y = b[0]
+            for item in b[1:]:
+                y &= item
+            z = c[0]
+            for item in c[1:]:
+                z &= item
+            return [x, y, z]
+        if eq.name == "f_not":
+            eq2 = helper2(eq.children[0])
+            a,b,c= eq2
+            d,e,f= [set(item) for item in out[1]]
+            return [d-a,e-b,f-c]
+        return helper2(dowhile(eq, lambda x: logic0(expand(simplify(eq)))))
+    out2 = helper2(eq)
+    
+    out = list(out)
+    out[1] = [set(item) for item in out[1]]
+    if tuple(out[1]) == (set(), set(), set()):
+        return eq
+    if tuple(out[1]) == tuple(out2):
+        return tree_form("s_true")
+    if tuple(out2) == (set(), set(), set()):
+        return tree_form("s_false")
+    return eq

mathai/diff.py

@@ -1,9 +1,9 @@
-from .simplify import solve
+from .simplify import simplify
 from .base import *
 from .trig import trig0
 def diff(equation, var="v_0"):
     def diffeq(eq):
-        eq = solve(eq)
+        eq = simplify(eq)
         if "v_" not in str_form(eq):
             return tree_form("d_0")
         if eq.name == "f_add":
@@ -65,4 +65,4 @@ def diff(equation, var="v_0"):
         return TreeNode(equation.name, [helper(child, var) for child in equation.children])
     equation = diffeq(trig0(equation))
     equation = helper(equation, var)
-    return solve(equation)
+    return simplify(equation)