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

mathai/__init__.py

@@ -39,8 +39,6 @@ from .logic import logic0, logic1, logic2, logic3
 
 from .apart import apart, apart2
 
-from .console import console
-
 from .limit import limit
 
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt

mathai/base.py

@@ -204,9 +204,11 @@ 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/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[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/parser.py

@@ -73,15 +73,9 @@ CNUMBER: /c[0-9]+/
 %ignore WS_INLINE
 """
 
-def parse(equation, funclist=None):
+def parse(equation):
     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)
@@ -118,21 +112,42 @@ def parse(equation, funclist=None):
 
     # Convert function names and constants
     def fxchange(tree_node):
-        tmp3 = funclist if funclist is not None else []
+        tmp3 = []
+
+        # Handle negation
         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])
-        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]
-        )
+
+        # 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])
+
 
     tree_node = fxchange(tree_node)
 

mathai/tool.py

@@ -4,6 +4,7 @@ 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,7 +9,71 @@ from .expand import expand
 from .fraction import fraction
 import copy
 from .diff import diff
-from .logic import logic0
+
+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
 def intersection2(domain, lst):
     domain = copy.deepcopy(domain)
     if domain == [True]:
@@ -23,14 +87,14 @@ def intersection2(domain, lst):
             
             if isinstance(domain[index], bool) and domain[index]:
                 
-                if index == 0 and compute(item2) < compute(domain[index+1]):
+                if index == 0 and less_than(item2, domain[index+1]):
                     
                     out.append(item2)
                     break
-                elif index == len(domain)-1 and compute(domain[index-1]) < compute(item2):
+                elif index == len(domain)-1 and less_than(domain[index-1], item2):
                     out.append(item2)
                     break
-                elif index != 0 and index != len(domain)-1 and compute(domain[index-1]) < compute(item2) and compute(item2) < compute(domain[index+1]):
+                elif index != 0 and index != len(domain)-1 and less_than(domain[index-1], item2) and less_than(item2, domain[index+1]):
                     
                     out.append(item2)
                     break
@@ -64,7 +128,8 @@ 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=lambda x: compute(x))
+    
+    result = sorted(result, key=cmp_to_key(custom_compare))
     i = len(result)
     while i>=0:
         result.insert(i, True)
@@ -216,7 +281,7 @@ def helper(eq, var="v_0"):
         item = simplify(expand(item))
         
         if len(vlist(item)) == 0:
-            if compute(item) <0:
+            if less_than(item, tree_form("d_0")):
                 sign = not sign
             continue
         v = vlist(item)[0]
@@ -230,12 +295,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 compute(a) < 0:
+                if less_than(a, tree_form("d_0")):
                     sign = not sign
                 continue
             else:
                 tmp2 = diff(copy.deepcopy(item))
-                if compute(tmp2)<0:
+                if less_than(tmp2, tree_form("d_0")):
                     sign = not sign
                     item = simplify(item * tree_form("d_-1"))
                 out = inverse(item, vlist(item)[0])
@@ -247,12 +312,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 compute(a) < 0:
+                if less_than(a, tree_form("d_0")):
                     sign = not sign
                 continue
             else:
                 tmp2 = diff(copy.deepcopy(item))
-                if compute(tmp2)<0:
+                if less_than(tmp2, tree_form("d_0")):
                     sign = not sign
                     item = simplify(item * tree_form("d_-1"))
                 out = inverse(item, vlist(item)[0])
@@ -264,7 +329,7 @@ def helper(eq, var="v_0"):
     critical = [simplify(item) for item in critical]
     critical = Counter(critical)
     
-    critical = sorted(critical.items(), key=lambda x: compute(x[0]))
+    critical = sorted(critical.items(), key=cmp_to_key(lambda a,b: custom_compare(a[0], b[0])))
 
     i = len(critical)
     element = sign

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.8
+Version: 0.4.9
 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.8.dist-info → mathai-0.4.9.dist-info}/RECORD

@@ -1,10 +1,9 @@
-mathai/__init__.py,sha256=p5Sx7a7I0lh_16izDFlwkI0FiRtJKUlRM3TDuCMAV3I,1450
+mathai/__init__.py,sha256=_cw5FqfRBxoeFYc-9EDbRuZ7ZGTSBslgNcMO4zR31Bs,1418
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=Ma1oCRbaZP0bp0Qnt_ZjKAh3rt9nZXQ_rmJL0sAoz5c,12730
-mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
+mathai/base.py,sha256=Di775V_upyhrel4--cNhG3Zskj5BKan0cAcjjFHjSzA,12721
 mathai/diff.py,sha256=YUBpRsz0qmBkq5vGxeGnvR4nMKjdOQiIXlNMxpij2ns,3051
 mathai/expand.py,sha256=SnBltkpIENMGkP0AYmbMlSc4H-CF5RslO2PcBEkn1BQ,3359
-mathai/factor.py,sha256=Xkx2_lxq-Z-t55dA9F2W4EH-3Uc1CFXj_6oESQdWAHM,11332
+mathai/factor.py,sha256=6iXnm-TB4HRjzCki5dLi_NNhFIiRYE3h7_c4111zta8,11509
 mathai/fraction.py,sha256=Q2ztsh5Bpz6YhML2QU0tfufbAs0Q6J319AhlzKephIY,4396
 mathai/integrate.py,sha256=ewV46QDD0-oiTWpSkmcpcZhBz9StcntbTV1tBLCo1Wo,16502
 mathai/inverse.py,sha256=QCvDrzKquWsZv-BDAzZd9HnU0c3gZvcc44UztHVO5LQ,2919
@@ -12,14 +11,14 @@ mathai/limit.py,sha256=bn7eofIOJv4AIh0-FmLppZ3DKnGfbwOzXks2XOPTOs0,4932
 mathai/linear.py,sha256=BzSnm941Zlod_l6hON4Rs6J4pdAA3MGpRVqr6-66ZBk,5524
 mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
 mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
-mathai/parser.py,sha256=f7bemieFmp0sbup1NlraMLvZDVFvqKGFknEVtlFRMVk,6979
+mathai/parser.py,sha256=XEeWgfqRinTAXWKFg5NtkTQWvFgMgtr0BfrJmvyuPQM,6970
 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=r8ejBY4Bnk_t8USYQCuxwmmJ4M-5H5OR6A3VbV7W-5w,6066
+mathai/tool.py,sha256=ivU4urQ9QxvfIO6bXqNtOvza4HnuZZfaO2m-bCuHaWc,6068
 mathai/trig.py,sha256=BQd_Gl_u0g5ZuZIwKozuXKbMinqb6K-OYicrtftn7eg,11174
-mathai/univariate_inequality.py,sha256=_r-kkiS4Hr-jRN7f-EL_E4svAMFWJP1Ea50HJKKbjfk,14778
-mathai-0.4.8.dist-info/METADATA,sha256=bmi6y4GCl3l9iKkCHL9Yz3yTM2wV2lnJkuHPMEajVH4,7103
-mathai-0.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mathai-0.4.8.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.4.8.dist-info/RECORD,,
+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/console.py

@@ -1,84 +0,0 @@
-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")