mathai 0.4.9__py3-none-any.whl → 0.5.1__py3-none-any.whl

mathai/__init__.py

@@ -1,7 +1,7 @@
 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
 
@@ -42,6 +42,7 @@ from .apart import apart, apart2
 from .limit import limit
 
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
+from .bivariate_inequality import inequality_solve
 
 from .base import *
 

mathai/base.py

@@ -204,11 +204,9 @@ def compute(eq):
 
     # 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_sub":

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/console.py

@@ -0,0 +1,84 @@
+import copy
+from .expand import expand
+from .parser import parse
+from .printeq import printeq, printeq_log
+from .simplify import solve, simplify
+
+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/factor.py

@@ -171,8 +171,7 @@ def factor_quar_formula_init():
 formula_gen9 = factor_quar_formula_init()
 def factor_helper(equation, complexnum, power=2):
     global formula_gen9
-    if equation.name[2:] in "and or not eq le ge lt gt".split(" "):
-        return TreeNode(equation.name, [factor_helper(child, complexnum, power) for child in equation.children])
+    
     maxnum=1
     alloclst = []
     for i in range(0,26):

mathai/linear.py

@@ -1,9 +1,12 @@
+from .inverse import inverse
+import itertools
 from .diff import diff
 from .simplify import simplify, solve
 from .fraction import fraction
 from .expand import expand
 from .base import *
 from .factor import factorconst
+from .tool import poly
 def ss(eq):
     return dowhile(eq, lambda x: fraction(expand(simplify(x))))
 def rref(matrix):
@@ -31,38 +34,16 @@ def rref(matrix):
     return matrix
 def islinear(eq, fxconst):
     eq =simplify(eq)
-    if eq.name == "f_pow" and fxconst(eq):#"v_" in str_form(eq):
-        return False
-    for child in eq.children:
-        out = islinear(child, fxconst)
-        if not out:
-            return out
-    return True
+    if all(fxconst(tree_form(item)) and poly(eq, item) is not None and len(poly(eq, item)) <= 2 for item in vlist(eq)):
+        return True
+    return False
 def linear(eqlist, fxconst):
-    final = []
-    extra = []
-    for i in range(len(eqlist)-1,-1,-1):
-        if eqlist[i].name == "f_mul" and not islinear(expand2(eqlist[i]), fxconst):
-            if "v_" in str_form(eqlist[i]):
-                eqlist[i] = TreeNode("f_mul", [child for child in eqlist[i].children if fxconst(child)])
-            if all(islinear(child, fxconst) for child in eqlist[i].children):
-                for child in eqlist[i].children:
-                    extra.append(TreeNode("f_eq", [child, tree_form("d_0")]))
-                eqlist.pop(i)
-            else:
-                final.append(TreeNode("f_eq", [eqlist[i], tree_form("d_0")]))
-                eqlist.pop(i)
+    orig = [item.copy_tree() for item in eqlist]
+    #eqlist = [eq for eq in eqlist if fxconst(eq)]
     
-    if extra != []:
-        final.append(TreeNode("f_or", extra))
-    if eqlist == []:
-        if len(final)==1:
-            
-            return final[0]
-        return TreeNode("f_and", final)
-    eqlist = [eq for eq in eqlist if fxconst(eq)]
-    if not all(islinear(eq, fxconst) for eq in eqlist):
-        return TreeNode("f_and", copy.deepcopy(final+eqlist))
+    if eqlist == [] or not all(islinear(eq, fxconst) for eq in eqlist):
+        return None
+        #return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in orig])
     vl = []
     def varlist(eq, fxconst):
         nonlocal vl
@@ -75,7 +56,7 @@ def linear(eqlist, fxconst):
     vl = list(set(vl))
     
     if len(vl) > len(eqlist):
-        return TreeNode("f_and", final+[TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
+        return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
     m = []
     for eq in eqlist:
         s = copy.deepcopy(eq)
@@ -94,63 +75,91 @@ def linear(eqlist, fxconst):
     for i in range(len(m)):
         for j in range(len(m[i])):
             m[i][j] = fraction(m[i][j])
-
-    for item in m:
-        if all(item2==tree_form("d_0") for item2 in item[:-1]) and item[-1] != tree_form("d_0"):
-            return tree_form("s_false")
     
     output = []
     for index, row in enumerate(m):
-        count = 0
-        for item in row[:-1]:
-            if item == tree_form("d_1"):
-                count += 1
-                if count == 2:
-                    break
-            elif item == tree_form("d_0") and count == 1:
-                break
-        if count == 0:
-            continue
-        output.append(tree_form(vl[index])+row[-1])
-    if len(output) == 1 and len(final)==0:
+        if not all(item == 0 for item in row[:-1]):
+            output.append(summation([tree_form(vl[index2])*coeff for index2, coeff in enumerate(row[:-1])])+row[-1])
+        elif row[-1] != 0:
+            return tree_form("s_false")
+    if len(output) == 1:
         return TreeNode("f_eq", [output[0], tree_form("d_0")])
-    return TreeNode("f_and", final+[TreeNode("f_eq", [x, tree_form("d_0")]) for x in output])
+    if len(output) == 0:
+        return tree_form("s_false")
+    return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in output])
+def order_collinear_indices(points, idx):
+    """
+    Arrange a subset of collinear points (given by indices) along their line.
+    
+    points: list of (x, y) tuples
+    idx: list of indices referring to points
+    Returns: list of indices sorted along the line
+    """
+    if len(idx) <= 1:
+        return idx[:]
+    
+    # Take first two points from the subset to define the line
+    p0, p1 = points[idx[0]], points[idx[1]]
+    dx, dy = p1[0] - p0[0], p1[1] - p0[1]
+    
+    # Projection factor for sorting
+    def projection_factor(i):
+        vx, vy = points[i][0] - p0[0], points[i][1] - p0[1]
+        return compute((vx * dx + vy * dy) / (dx**2 + dy**2))
+    
+    # Sort indices by projection
+    sorted_idx = sorted(idx, key=projection_factor)
+    return list(sorted_idx)
+def linear_or(eq):
+    eqlst =[]
+    if eq.name != "f_or":
+        eqlst = [eq]
+    else:
+        eqlst = eq.children
+    v = vlist(eq)
+    p = []
+    line = {}
+    for i in range(len(eqlst)):
+        line[i] = []
+    for item in itertools.combinations(enumerate(eqlst), 2):
+        x, y = item[0][0],  item[1][0]
+        item = [item[0][1], item[1][1]]
+        
+        out = linear_solve(TreeNode("f_and", list(item)))
 
-def rmeq(eq):
-    if eq.name == "f_eq":
-        return rmeq(eq.children[0])
-    return TreeNode(eq.name, [rmeq(child) for child in eq.children])
+        if out is None:
+            return None
+        
+        if out.name == "f_and" and all(len(vlist(child)) == 1 for child in out.children) and set(vlist(out)) == set(v) and all(len(vlist(simplify(child))) >0 for child in out.children):
+            t = {}
+            for child in out.children:
+                t[v.index(vlist(child)[0])] = simplify(inverse(child.children[0], vlist(child)[0]))
+            t2 = []
+            for key in sorted(t.keys()):
+                t2.append(t[key])
+            t2 = tuple(t2)
+            if t2 not in p:
+                p.append(t2)
+            line[x] += [p.index(t2)]
+            line[y] += [p.index(t2)]
+    line2 = []
+    for key in sorted(line.keys()):
+        line2.append(order_collinear_indices(p, list(set(line[key]))))
 
-def mat0(eq, lst=None):
-    def findeq(eq):
-        out = []
-        if "f_list" not in str_form(eq) and "f_eq" not in str_form(eq):
-            return [str_form(eq)]
-        else:
-            for child in eq.children:
-                out += findeq(child)
-        return out
-    eqlist = findeq(eq)
-    eqlist = [tree_form(x) for x in eqlist]
-    eqlist = [rmeq(x) for x in eqlist]
-    eqlist = [TreeNode("f_mul", factor_generation(x)) for x in eqlist if x != tree_form("d_0")]
-    eqlist = [x.children[0] if len(x.children) == 1 else x for x in eqlist]
+    return v, p, line2, eqlst
+def linear_solve(eq, lst=None):
+    eq = simplify(eq)
+    eqlist = []
+    if eq.name =="f_and" and all(child.name == "f_eq" and child.children[1] == 0 for child in eq.children):
+        
+        eqlist = [child.children[0] for child in eq.children]
+    else:
+        return eq
     out = None
-    
     if lst is None:
         out = linear(copy.deepcopy(eqlist), lambda x: "v_" in str_form(x))
     else:
         out = linear(copy.deepcopy(eqlist), lambda x: any(contain(x, item) for item in lst))
-    def rms(eq):
-        if eq.name in ["f_and", "f_or"] and len(eq.children) == 1:
-            return eq.children[0]
-        return TreeNode(eq.name, [rms(child) for child in eq.children])
-    return rms(out)
-def linear_solve(eq, lst=None):
-    if eq.name == "f_and":
-        eq2 = copy.deepcopy(eq)
-        eq2.name = "f_list"
-        return mat0(eq2, lst)
-    elif eq.name == "f_eq":
-        return mat0(eq, lst)
-    return TreeNode(eq.name, [linear_solve(child, lst) for child in eq.children])
+    if out is None:
+        return None
+    return simplify(out)

mathai/parser.py

@@ -73,9 +73,15 @@ CNUMBER: /c[0-9]+/
 %ignore WS_INLINE
 """
 
-def parse(equation):
+def parse(equation, funclist=None):
     equation = copy.copy(equation.replace(" ", ""))
     grammar2 = copy.deepcopy(grammar)
+    if funclist is not None:
+        output = grammar2.split("\n")
+        for i in range(len(output)):
+            if "FUNC_NAME:" in output[i]:
+                output[i] = output[i].replace("FUNC_NAME: ", "FUNC_NAME: " + " | ".join(['"' + x + '"' for x in funclist]) + " | ")
+        grammar2 = "\n".join(output)
 
     parser_main = Lark(grammar2, start='start', parser='lalr')
     parse_tree = parser_main.parse(equation)
@@ -112,42 +118,21 @@ def parse(equation):
 
     # Convert function names and constants
     def fxchange(tree_node):
-        tmp3 = []
-
-        # Handle negation
+        tmp3 = funclist if funclist is not None else []
         if tree_node.name == "neg":
             child = fxchange(tree_node.children[0])
+            # if the child is a number, make it negative
             if child.name.startswith("d_") and re.match(r"d_\d+(\.\d+)?$", child.name):
                 return TreeNode("d_" + str(-int(child.name[2:])))
             else:
+                # otherwise subtract from zero
                 return TreeNode("f_sub", [tree_form("d_0"), child])
-
-        # Pass through node
         if tree_node.name == "pass_through":
             return fxchange(tree_node.children[0])
-
-        # Define function name categories
-        builtin_funcs = tmp3 + [
-            "try","ref","sqrt","imply","forall","exist","exclude","union","intersection","len",
-            "index","angle","charge","sum2","electricfield","line","point","sum","transpose",
-            "equationrhs","equationlhs","equation","covariance","variance","expect","error",
-            "laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt",
-            "eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2",
-            "line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv",
-            "or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul",
-            "integrate","dif","pow","div","log","abs"
-        ]
-
-        # --- NEW: detect F + digits ---
-        if re.match(r"F\d+$", tree_node.name):
-            new_name = "f_" + tree_node.name  # e.g., F12 → f_F12
-        elif tree_node.name in builtin_funcs:
-            new_name = "f_" + tree_node.name
-        else:
-            new_name = "d_" + tree_node.name
-
-        return TreeNode(new_name, [fxchange(child) for child in tree_node.children])
-
+        return TreeNode(
+            "f_" + tree_node.name if tree_node.name in tmp3 + ["try", "ref", "sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
+            [fxchange(child) for child in tree_node.children]
+        )
 
     tree_node = fxchange(tree_node)
 

mathai/tool.py

@@ -4,7 +4,6 @@ from .simplify import simplify, solve
 from .base import *
 import math
 
-
 def poly_div(dividend_coeffs, divisor_coeffs):
     """
     Perform polynomial division using coefficients with symbolic simplification.

mathai/univariate_inequality.py

@@ -9,71 +9,7 @@ from .expand import expand
 from .fraction import fraction
 import copy
 from .diff import diff
-
-from .factor import merge_sqrt
-from .factor import rationalize_sqrt as rationalize
-
-from functools import cmp_to_key
-
-
-def arithmetic(eq):
-    eq = dowhile(eq, lambda x: handle_sqrt(simplify(merge_sqrt(rationalize(x)))))
-    def helper(eq):
-        if eq.name[2:] in "le ge gt lt eq".split(" "):
-            a, b = frac(eq.children[0]), frac(eq.children[1])
-            
-            if a is not None and b is not None:
-                out = {"le": lambda x, y: x <= y, "ge":lambda x, y: x >= y, "lt":lambda x, y: x < y,\
-                       "gt":lambda x, y: x > y, "eq":lambda x, y: x == y}[eq.name[2:]](a, b)
-                if out:
-                    return tree_form("s_true")
-                else:
-                    return tree_form("s_false")
-        return TreeNode(eq.name, [helper(child) for child in eq.children])
-    def helper2(eq):
-        if eq.children == []:
-            if eq == tree_form("s_true"):
-                return True
-            elif eq == tree_form("s_false"):
-                return False
-            else:
-                return None
-        if eq.name == "f_or":
-            out = [helper2(child) for child in eq.children]
-            if None in out:
-                return None
-            return any(out)
-        if eq.name == "f_and":
-            out = [helper2(child) for child in eq.children]
-            if None in out:
-                return None
-            return all(out)
-        if eq.name == "f_not":
-            out = [helper2(child) for child in eq.children]
-            if None in out:
-                return None
-            return not out[0]
-        return None
-    
-    return helper2(eq)
-
-def less_than(eq1, eq2):
-    return arithmetic(TreeNode("f_le", [eq1,eq2]))
-def equal_to(eq1, eq2):
-    return arithmetic(TreeNode("f_eq", [eq1,eq2]))
-def custom_compare(a, b):
-        
-        y = equal_to(a, b)
-        if y is not None:
-            if y:
-                return -1
-        x = less_than(a, b)
-        if x is not None:
-            if x:
-                return -1
-            else:
-                return 1
-        return 0
+from .logic import logic0
 def intersection2(domain, lst):
     domain = copy.deepcopy(domain)
     if domain == [True]:
@@ -87,14 +23,14 @@ def intersection2(domain, lst):
             
             if isinstance(domain[index], bool) and domain[index]:
                 
-                if index == 0 and less_than(item2, domain[index+1]):
+                if index == 0 and compute(item2) < compute(domain[index+1]):
                     
                     out.append(item2)
                     break
-                elif index == len(domain)-1 and less_than(domain[index-1], item2):
+                elif index == len(domain)-1 and compute(domain[index-1]) < compute(item2):
                     out.append(item2)
                     break
-                elif index != 0 and index != len(domain)-1 and less_than(domain[index-1], item2) and less_than(item2, domain[index+1]):
+                elif index != 0 and index != len(domain)-1 and compute(domain[index-1]) < compute(item2) and compute(item2) < compute(domain[index+1]):
                     
                     out.append(item2)
                     break
@@ -128,8 +64,7 @@ def intersection(domain_1, domain_2):
     result = domain_1 + domain_2
     result = [item for item in result if not isinstance(item, bool)]
     result = list(set(result))
-    
-    result = sorted(result, key=cmp_to_key(custom_compare))
+    result = sorted(result, key=lambda x: compute(x))
     i = len(result)
     while i>=0:
         result.insert(i, True)
@@ -281,7 +216,7 @@ def helper(eq, var="v_0"):
         item = simplify(expand(item))
         
         if len(vlist(item)) == 0:
-            if less_than(item, tree_form("d_0")):
+            if compute(item) <0:
                 sign = not sign
             continue
         v = vlist(item)[0]
@@ -295,12 +230,12 @@ def helper(eq, var="v_0"):
                 a = replace(diff(diff(item, v), v), tree_form(v), tree_form("d_0"))/tree_form("d_2")
                 if "v_" in str_form(a):
                     return None
-                if less_than(a, tree_form("d_0")):
+                if compute(a) < 0:
                     sign = not sign
                 continue
             else:
                 tmp2 = diff(copy.deepcopy(item))
-                if less_than(tmp2, tree_form("d_0")):
+                if compute(tmp2)<0:
                     sign = not sign
                     item = simplify(item * tree_form("d_-1"))
                 out = inverse(item, vlist(item)[0])
@@ -312,12 +247,12 @@ def helper(eq, var="v_0"):
                 a = replace(diff(diff(item, v), v), tree_form(v), tree_form("d_0"))/tree_form("d_2")
                 if "v_" in str_form(a):
                     return None
-                if less_than(a, tree_form("d_0")):
+                if compute(a) < 0:
                     sign = not sign
                 continue
             else:
                 tmp2 = diff(copy.deepcopy(item))
-                if less_than(tmp2, tree_form("d_0")):
+                if compute(tmp2)<0:
                     sign = not sign
                     item = simplify(item * tree_form("d_-1"))
                 out = inverse(item, vlist(item)[0])
@@ -329,7 +264,7 @@ def helper(eq, var="v_0"):
     critical = [simplify(item) for item in critical]
     critical = Counter(critical)
     
-    critical = sorted(critical.items(), key=cmp_to_key(lambda a,b: custom_compare(a[0], b[0])))
+    critical = sorted(critical.items(), key=lambda x: compute(x[0]))
 
     i = len(critical)
     element = sign

{mathai-0.4.9.dist-info → mathai-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.9
+Version: 0.5.1
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Author: educated indians are having a low iq and are good for nothing

{mathai-0.4.9.dist-info → mathai-0.5.1.dist-info}/RECORD

@@ -1,24 +1,26 @@
-mathai/__init__.py,sha256=_cw5FqfRBxoeFYc-9EDbRuZ7ZGTSBslgNcMO4zR31Bs,1418
+mathai/__init__.py,sha256=O3P2_Q64gwo1CmgD4cwhl3fGUQc3wGa0-b9z8MBtFaI,1481
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=Di775V_upyhrel4--cNhG3Zskj5BKan0cAcjjFHjSzA,12721
+mathai/base.py,sha256=Ma1oCRbaZP0bp0Qnt_ZjKAh3rt9nZXQ_rmJL0sAoz5c,12730
+mathai/bivariate_inequality.py,sha256=FJOC2zKU5zWCMybCrhEQ7nVDgRO_w19Zko8WPTaDTSo,11411
+mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
 mathai/diff.py,sha256=YUBpRsz0qmBkq5vGxeGnvR4nMKjdOQiIXlNMxpij2ns,3051
 mathai/expand.py,sha256=SnBltkpIENMGkP0AYmbMlSc4H-CF5RslO2PcBEkn1BQ,3359
-mathai/factor.py,sha256=6iXnm-TB4HRjzCki5dLi_NNhFIiRYE3h7_c4111zta8,11509
+mathai/factor.py,sha256=Xkx2_lxq-Z-t55dA9F2W4EH-3Uc1CFXj_6oESQdWAHM,11332
 mathai/fraction.py,sha256=Q2ztsh5Bpz6YhML2QU0tfufbAs0Q6J319AhlzKephIY,4396
 mathai/integrate.py,sha256=ewV46QDD0-oiTWpSkmcpcZhBz9StcntbTV1tBLCo1Wo,16502
 mathai/inverse.py,sha256=QCvDrzKquWsZv-BDAzZd9HnU0c3gZvcc44UztHVO5LQ,2919
 mathai/limit.py,sha256=bn7eofIOJv4AIh0-FmLppZ3DKnGfbwOzXks2XOPTOs0,4932
-mathai/linear.py,sha256=BzSnm941Zlod_l6hON4Rs6J4pdAA3MGpRVqr6-66ZBk,5524
+mathai/linear.py,sha256=Mmmnn4IdnADRMuv6crB0a_Ba2drGUFXOh7eqIIkirYA,5709
 mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
 mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
-mathai/parser.py,sha256=XEeWgfqRinTAXWKFg5NtkTQWvFgMgtr0BfrJmvyuPQM,6970
+mathai/parser.py,sha256=f7bemieFmp0sbup1NlraMLvZDVFvqKGFknEVtlFRMVk,6979
 mathai/printeq.py,sha256=gIes-pstFOa6FcnpVIVvkjVKuWdsVdo11LlEnmHhakU,1303
 mathai/simplify.py,sha256=nR5IReewrJ7HbxEUzQ2zg9xoFcwI1R5lGjWnX1pBKko,16885
 mathai/structure.py,sha256=4Ww2IAx62RcQSO7_17TZES-DjMWBpcFQtL939FBIHwY,4103
-mathai/tool.py,sha256=ivU4urQ9QxvfIO6bXqNtOvza4HnuZZfaO2m-bCuHaWc,6068
+mathai/tool.py,sha256=r8ejBY4Bnk_t8USYQCuxwmmJ4M-5H5OR6A3VbV7W-5w,6066
 mathai/trig.py,sha256=BQd_Gl_u0g5ZuZIwKozuXKbMinqb6K-OYicrtftn7eg,11174
-mathai/univariate_inequality.py,sha256=4Uwzneoofb-q8hFg6TsqK1SZTBCnGHbYUU9XoyspA5M,16996
-mathai-0.4.9.dist-info/METADATA,sha256=C4r7cP1Tp2SpN22TaTyobAKHaSGdW2FeyJ4ie3A9X54,7103
-mathai-0.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mathai-0.4.9.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.4.9.dist-info/RECORD,,
+mathai/univariate_inequality.py,sha256=_r-kkiS4Hr-jRN7f-EL_E4svAMFWJP1Ea50HJKKbjfk,14778
+mathai-0.5.1.dist-info/METADATA,sha256=zPDi8RasVepSv0JP4bBx_LszViwltoRJSgR3HOvLNkQ,7103
+mathai-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mathai-0.5.1.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.5.1.dist-info/RECORD,,