mathai 0.5.0__tar.gz → 0.5.2__tar.gz

{mathai-0.5.0 → mathai-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → mathai-0.5.2}/mathai/__init__.py

@@ -44,6 +44,8 @@ from .limit import limit
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
 from .bivariate_inequality import inequality_solve
 
+from .matrix import uncommute
+
 from .base import *
 
 from .tool import enclose_const

{mathai-0.5.0 → mathai-0.5.2}/mathai/bivariate_inequality.py

@@ -4,6 +4,9 @@ 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
@@ -73,8 +76,6 @@ def deterministic_middle_point(vertices, grid_resolution=100):
     return best_point
 
 def build(eq):
-    if len(eq) <= 1:
-        return None
     eq = TreeNode("f_or", eq)
     eq = flatten_tree(eq)
     orig = eq.copy_tree()
@@ -85,15 +86,21 @@ def build(eq):
     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 vlist(eq)])))
+                                                      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):
@@ -175,6 +182,7 @@ def build(eq):
             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]:
@@ -185,7 +193,9 @@ def build(eq):
                 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])):
@@ -193,8 +203,6 @@ def build(eq):
     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):
-        if "f_eq" in str_form(eq):
-            return False
         nonlocal result2
         if eq.name[:2] == "d_":
             return float(eq.name[2:])
@@ -204,12 +212,20 @@ def build(eq):
             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)
-        return {"gt":lambda a,b: a>b, "lt":lambda a,b: a<b}[eq.name[2:]](work(eq.children[0], point), work(eq.children[1], point))
+        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(set(item) & set(point_lst))
-        b = tuple(set([tuple(sorted([item[i], item[i+1]])) for i in range(len(item)-1)]) & set(line))
+        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))
         
@@ -220,16 +236,19 @@ def build(eq):
     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
     
@@ -284,11 +303,13 @@ def inequality_solve(eq):
             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()):

{mathai-0.5.0 → mathai-0.5.2}/mathai/factor.py

@@ -171,7 +171,8 @@ def factor_quar_formula_init():
 formula_gen9 = factor_quar_formula_init()
 def factor_helper(equation, complexnum, power=2):
     global formula_gen9
-    
+    if equation.name in ["f_or", "f_and", "f_not", "f_eq", "f_gt", "f_lt", "f_ge", "f_le"]:
+        return TreeNode(equation.name, [factor_helper(child, complexnum, power) for child in equation.children])
     maxnum=1
     alloclst = []
     for i in range(0,26):

{mathai-0.5.0 → mathai-0.5.2}/mathai/linear.py

@@ -6,6 +6,7 @@ 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):
@@ -33,17 +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):
-    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(eqlist))
+    orig = [item.copy_tree() for item in eqlist]
+    #eqlist = [eq for eq in eqlist if fxconst(eq)]
+    
+    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
@@ -111,7 +111,6 @@ def order_collinear_indices(points, idx):
     sorted_idx = sorted(idx, key=projection_factor)
     return list(sorted_idx)
 def linear_or(eq):
-    eq = simplify(eq)
     eqlst =[]
     if eq.name != "f_or":
         eqlst = [eq]
@@ -125,8 +124,13 @@ def linear_or(eq):
     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)))
-        if out.name == "f_and" and all(len(vlist(child)) == 1 for child in out.children) and set(vlist(out)) == set(v):
+
+        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]))
@@ -141,11 +145,13 @@ def linear_or(eq):
     line2 = []
     for key in sorted(line.keys()):
         line2.append(order_collinear_indices(p, list(set(line[key]))))
+
     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
@@ -154,4 +160,6 @@ def linear_solve(eq, lst=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))
+    if out is None:
+        return None
     return simplify(out)

mathai-0.5.2/mathai/matrix.py

@@ -0,0 +1,22 @@
+def uncommute(eq, inside=False):
+    if not inside and eq.name in ["f_add", "f_mul"]:
+        return TreeNode(eq.name[:2]+"w"+eq.name[2:], [uncommute(child) for child in eq.children])
+    return TreeNode(eq.name, [uncommute(child, True) if eq.name == "f_list" else uncommute(child, inside) for child in eq.children])
+
+def matrix_solve(eq):
+    if eq.name == "f_wadd":
+        output = None
+        output2 = []
+        for child in eq.children:
+            if child.name == "f_list":
+                if output is None:
+                    output = []
+                    for i in range(len(child.children)):
+                        output.append([child.children[i]])
+                else:
+                    for i in range(len(child.children)):
+                        output[i] += [child.children[i]]
+                output.append(child)
+            else:
+                output2.append(child)
+        output = [summation(item) for item in output]

{mathai-0.5.0 → mathai-0.5.2}/mathai/simplify.py

@@ -159,7 +159,12 @@ def clear_div(eq, denom=False):
     if len(lst3) % 2 == 1:
         sign = False
     if denom:
-        return eq if sign else -eq, sign
+        eq2 = [item for item in lst if "v_" not in str_form(item)]
+        eq3 = [item for item in lst if "v_" in str_form(item)]
+        if eq3 == []:
+            return solve(product(eq2)),True
+        return solve(product(eq3)),sign
+        #return eq if sign else -eq, sign
     lst = [item for item in lst if not(item.name == "f_pow" and frac(item.children[1]) is not None and frac(item.children[1]) == -1)]
 
     lst2 = [item for item in lst if "v_" in str_form(item)]

{mathai-0.5.0 → mathai-0.5.2}/mathai/univariate_inequality.py

@@ -361,7 +361,9 @@ def absolute(equation):
         equation = TreeNode("f_or", out2)
     return equation
 def handle_sqrt(eq):
+    d= []
     def helper2(eq):
+        nonlocal d
         if eq.name in ["f_lt", "f_gt", "f_le", "f_ge","f_eq"]:
             out = []
             def helper(eq):
@@ -378,11 +380,17 @@ def handle_sqrt(eq):
                     eq2, sgn = inverse(simplify(eq.children[0]), str_form(item), True)
                     if sgn == False:
                         n = tree_form("d_-1")
+                d.append(TreeNode("f_ge", [eq2,tree_form("d_0")]))
+                #d.append(TreeNode("f_ge", [item.children[0],tree_form("d_0")]))
                 eq3 = simplify(expand(simplify(eq2**2)))
                 
                 return simplify(TreeNode(eq.name, [simplify(n*item.children[0]-eq3*n), tree_form("d_0")]))
+            
         return TreeNode(eq.name, [helper2(child) for child in eq.children])
-    return helper2(eq)
+    out = helper2(eq)
+    if len(d) == 0:
+        return out
+    return TreeNode("f_and", [helper2(eq)]+d)
 def domain(eq):
     eq = solve(eq, True)
     out = []

{mathai-0.5.0 → mathai-0.5.2}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → mathai-0.5.2}/mathai.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ mathai/inverse.py
 mathai/limit.py
 mathai/linear.py
 mathai/logic.py
+mathai/matrix.py
 mathai/ode.py
 mathai/parser.py
 mathai/printeq.py

{mathai-0.5.0 → mathai-0.5.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="0.5.0",
+    version="0.5.2",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",