mathai 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

mathai/parser.py

@@ -59,7 +59,7 @@ grammar = """
      | ESCAPED_STRING      -> string
      | CAPITAL_ID          -> matrix
 
-FUNC_NAME: "midpoint" | "forall" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
+FUNC_NAME: "midpoint" | "ref" | "subs" | "try" | "forall" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
 
 VARIABLE: /[a-z]/ | "nabla" | "pi" | "kc" | "hbar" | "em" | "ec" | "anot" | "false" | "true"
 
@@ -130,7 +130,7 @@ def parse(equation, funclist=None):
         if tree_node.name == "pass_through":
             return fxchange(tree_node.children[0])
         return TreeNode(
-            "f_" + tree_node.name if tree_node.name in tmp3 + ["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,
+            "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]
         )
 

mathai/printeq.py

@@ -24,7 +24,7 @@ def abstractexpr(eq):
     return TreeNode(eq.name, [abstractexpr(child) for child in eq.children])
 
 def printeq_str(eq):
-    return str(dowhile(copy.deepcopy(eq), abstractexpr))
+    return str(dowhile(eq, abstractexpr))
 
 def printeq(eq):
     print(printeq_str(eq))

mathai/search.py

@@ -2,110 +2,107 @@ from mathai import *
 import copy
 from concurrent.futures import ThreadPoolExecutor, TimeoutError
 
-def dfs_simplify(equation, functions, true_expr, false_expr,
-                 max_timeout=25, max_small=4,
-                 base_timeout=1, time_per_char=0.1, timeout_increase=0.5):
-    """
-    Perform DFS simplification on a given equation using provided functions.
-
-    Args:
-        equation: The starting expression (TreeNode or parsed equation)
-        functions: List of simplification functions
-        true_expr: Expression representing True (immediate termination)
-        false_expr: Expression representing False (immediate termination)
-        max_timeout: Maximum timeout allowed for any function
-        max_small: Number of smallest expressions to track
-        base_timeout: Base timeout in seconds
-        time_per_char: Additional timeout per character of expression
-        timeout_increase: Factor to increase timeout for consecutive timeouts
-
-    Returns:
-        tuple(found_boolean, boolean_path, smallest_expressions)
-    """
-    original_eq = simplify(equation)
-    smallest_four = []
-
-    stack = [(copy.deepcopy(original_eq), [copy.deepcopy(original_eq)])]
-    visited = set()
-
-    found_boolean = False
-    boolean_path = None
-    boolean_expr = None
-
-    executor = ThreadPoolExecutor(max_workers=3)
-    consecutive_timeouts = 0
-
-    while stack and not found_boolean:
-        current_eq, path = stack.pop()
-        expr_str = str(current_eq)
-
-        if expr_str in visited:
-            continue
-        visited.add(expr_str)
+# Original expression
+original_eq = simplify(parse("((P|~Q)&(P&~Q|P&R)&(~P&~R|~Q))<->P&~Q"))
 
-        # Thinking message
-        printeq(current_eq)
+# Simplification functions
+lst = [logic1, logic3, logic2]
+
+MAX_SMALL = 2
+smallest_four = []
+
+# Stack element: (current_expr, path_list)
+stack = [(copy.deepcopy(original_eq), [copy.deepcopy(original_eq)])]
+
+# Keep track of visited expressions to prevent cycles
+visited = set()
+
+# Boolean constants for immediate termination
+TRUE_EXPR = tree_form("s_true")
+FALSE_EXPR = tree_form("s_false")
+
+found_boolean = False
+boolean_path = None
+boolean_expr = None
 
-        # Immediate termination for provided boolean expressions
-        if current_eq == true_expr or current_eq == false_expr:
-            found_boolean = True
-            boolean_path = path
-            boolean_expr = current_eq
+# Thread pool executor
+executor = ThreadPoolExecutor(max_workers=3)
+
+while stack and not found_boolean:
+    current_eq, path = stack.pop()
+    expr_str = str(current_eq)
+
+    if expr_str in visited:
+        continue
+    visited.add(expr_str)
+
+    # Thinking message
+    printeq(current_eq)
+
+    # Immediate termination for boolean constants
+    if current_eq == TRUE_EXPR or current_eq == FALSE_EXPR:
+        found_boolean = True
+        boolean_path = path
+        boolean_expr = current_eq
+        break
+
+    # Insert into smallest_four if qualifies
+    inserted = False
+    for j in range(len(smallest_four)):
+        if len(expr_str) < len(str(smallest_four[j][0])):
+            smallest_four.insert(j, (copy.deepcopy(current_eq), copy.deepcopy(path)))
+            inserted = True
             break
+    if not inserted and len(smallest_four) < MAX_SMALL:
+        smallest_four.append((copy.deepcopy(current_eq), copy.deepcopy(path)))
+    if len(smallest_four) > MAX_SMALL:
+        smallest_four = smallest_four[:MAX_SMALL]
+
+    # First, try functions that reduce length
+    reduced_any = False
+    for fx in lst:
+        print(f"[Thinking] Executing {fx.__name__} on current expression:")
+        printeq(current_eq)
+        future = executor.submit(fx, current_eq)
+        try:
+            new_expr = future.result(timeout=5)
+            new_expr_str = str(new_expr)
+            # Only accept if shorter or equal
+            if len(new_expr_str) <= len(expr_str) and new_expr_str != expr_str:
+                reduced_any = True
+                stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
+        except TimeoutError:
+            print(f"[Thinking] {fx.__name__} timed out, skipping.")
+            continue
 
-        # Insert into smallest_four if qualifies
-        inserted = False
-        for j in range(len(smallest_four)):
-            if len(expr_str) < len(str(smallest_four[j][0])):
-                smallest_four.insert(j, (copy.deepcopy(current_eq), copy.deepcopy(path)))
-                inserted = True
-                break
-        if not inserted and len(smallest_four) < max_small:
-            smallest_four.append((copy.deepcopy(current_eq), copy.deepcopy(path)))
-        if len(smallest_four) > max_small:
-            smallest_four = smallest_four[:max_small]
-
-        # Calculate adaptive timeout with cap
-        timeout = (base_timeout + time_per_char * len(expr_str)) * (1 + timeout_increase * consecutive_timeouts)
-        if timeout > max_timeout:
-            timeout = max_timeout
-
-        # Try functions that reduce length first
-        reduced_any = False
-        for fx in functions:
-            print(f"[Thinking] Executing {fx.__name__} on current expression (timeout={timeout:.2f}s):")
+    # If no reducing function produced a shorter or equal expression, try a “growing” function
+    if not reduced_any:
+        for fx in lst:
+            print(f"[Thinking] Trying growing {fx.__name__} on current expression:")
             printeq(current_eq)
             future = executor.submit(fx, current_eq)
             try:
-                new_expr = future.result(timeout=timeout)
+                new_expr = future.result(timeout=5)
                 new_expr_str = str(new_expr)
-                if len(new_expr_str) <= len(expr_str) and new_expr_str != expr_str:
-                    reduced_any = True
+                if new_expr_str != expr_str:
                     stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-                consecutive_timeouts = 0  # reset after success
+                    break  # only take one growing function
             except TimeoutError:
-                print(f"[Thinking] {fx.__name__} timed out, skipping.")
-                consecutive_timeouts += 1
+                print(f"[Thinking] {fx.__name__} (growing) timed out, skipping.")
                 continue
 
-        # If no reducing function worked, try growing functions
-        if not reduced_any:
-            for fx in functions:
-                print(f"[Thinking] Trying growing {fx.__name__} on current expression (timeout={timeout:.2f}s):")
-                printeq(current_eq)
-                future = executor.submit(fx, current_eq)
-                try:
-                    new_expr = future.result(timeout=timeout)
-                    new_expr_str = str(new_expr)
-                    if new_expr_str != expr_str:
-                        stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-                        consecutive_timeouts = 0
-                        break  # only take one growing function
-                except TimeoutError:
-                    print(f"[Thinking] {fx.__name__} (growing) timed out, skipping.")
-                    consecutive_timeouts += 1
-                    continue
-
-    executor.shutdown(wait=True)
-
-    return found_boolean, boolean_path, smallest_four
+# Shutdown executor
+executor.shutdown(wait=True)
+
+# Display final results
+if found_boolean:
+    print("\nBoolean constant found! Full path to solution:\n")
+    for step in boolean_path:
+        printeq(step)
+else:
+    print("\nDFS completed. Two smallest expressions with steps:\n")
+    for expr, path in smallest_four:
+        print("Path to final expression:")
+        for step in path:
+            printeq(step)
+        print("-"*50)

mathai/simplify.py

@@ -1,7 +1,10 @@
 import math
 from .base import *
 from fractions import Fraction
-
+nolog = False
+def set_nolog(val):
+    global nolog
+    nolog = val
 def _solve(eq):
     def solve_add(eq):
         def multiplied(eq):
@@ -269,12 +272,13 @@ def simplify(eq):
                     out = perfect_nth_root_value(n, r)
                     if out is not None:
                         return pp( tree_form("d_"+str(out)), f)
-        if eq.name == "f_mul" and len(eq.children)== 2:
-            for i in range(2):
-                if eq.children[i].name[:2] == "d_" and eq.children[1-i].name == "f_log":
-                    return (eq.children[1-i].children[0]**eq.children[i]).fx("log")
-        if eq.name == "f_pow" and eq.children[0] == tree_form("s_e") and eq.children[1].name == "f_log":
-            return eq.children[1].children[0]
+        if not nolog:
+            if eq.name == "f_mul" and len(eq.children)== 2:
+                for i in range(2):
+                    if eq.children[i].name[:2] == "d_" and eq.children[1-i].name == "f_log":
+                        return (eq.children[1-i].children[0]**eq.children[i]).fx("log")
+            if eq.name == "f_pow" and eq.children[0] == tree_form("s_e") and eq.children[1].name == "f_log":
+                return eq.children[1].children[0]
         if eq.name == "f_pow" and eq.children[0] == tree_form("d_1"):
             eq = tree_form("d_1")
         if eq.name == "f_pow" and eq.children[0] == tree_form("d_0"):

mathai/structure.py

@@ -90,7 +90,7 @@ def transform_formula(equation, wrt, formula_list, var, expr):
             if var != "":
                 p = True
             try:
-                out = structure(copy.deepcopy(equation), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p)
+                out = structure(equation.copy_tree(), copy.deepcopy(item[0]), copy.deepcopy(item[1]), p)
                 if out is not None:
                     out = simplify(out)
                     

mathai/tool.py

@@ -4,12 +4,39 @@ from .simplify import simplify
 from .base import *
 import math
 
+def enclose_const(eq):
+    def req(eq, dic):
+        for key in dic.keys():
+            eq  = replace(eq, dic[key], key)
+        return eq
+    alloclst = []
+    for i in range(0,26):
+        if "v_"+str(i) not in vlist(eq):
+            alloclst.append(tree_form("v_"+str(i)))
+    dic = {}
+    def helper(eq):
+        nonlocal alloclst, dic
+        if frac(eq) is not None:
+            return eq
+        
+        if "v_" not in str_form(eq):
+            if eq not in dic.keys():
+                n = alloclst.pop(0)
+                dic[eq] = n
+            return dic[eq]
+        else:
+            if eq.name == "f_pow":
+                return TreeNode(eq.name, [helper(eq.children[0]), eq.children[1]])
+            return TreeNode(eq.name, [helper(child) for child in eq.children])
+    eq= helper(eq)
+    return eq, lambda x: req(x, dic)
+
 def poly(eq, to_compute):
     def substitute_val(eq, val, var="v_0"):
         eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
         return eq
     def inv(eq):
-        if eq.name == "f_pow" and eq.children[1] == tree_form("d_-1"):
+        if eq.name == "f_pow" and "v_" in str_form(eq.children[0]) and eq.children[1] == tree_form("d_-1"):
             return False
         if eq.name == "f_abs":
             return False

mathai/trig.py

@@ -65,6 +65,8 @@ def trig0(eq):
         if eq.children[0].name == "d_1":
             return tree_form("d_0")
     if eq.name=="f_tan":
+        if eq.children[0].name == "f_arctan":
+            return eq.children[0].children[0]
         return eq.children[0].fx("sin")/eq.children[0].fx("cos")
     if eq.name == "f_sec":
         return eq.children[0].fx("cos")**-1
@@ -72,14 +74,20 @@ def trig0(eq):
         return eq.children[0].fx("sin")**-1
     if eq.name == "f_cot":
         return eq.children[0].fx("cos")/eq.children[0].fx("sin")
+    
     if eq.name == "f_sin":
+        if eq.children[0].name == "f_arcsin":
+            return eq.children[0].children[0]
         lst = factor_generation(eq.children[0])
         if any(isneg(item) for item in lst):
             return -(eq.children[0]*-1).fx("sin")
         out=single_pi(lst)
         if out is not None:
             return trig_sin_table[tuple(out)]
+    
     if eq.name == "f_cos":
+        if eq.children[0].name == "f_arccos":
+            return eq.children[0].children[0]
         lst = factor_generation(eq.children[0])
         if any(isneg(item) for item in lst):
             return (eq.children[0]*-1).fx("cos")
@@ -122,11 +130,13 @@ def trig_formula_init():
                     (f"1/cos(B)^2", f"1/(1-sin(B)^2)"),\
                     (f"cos(arcsin(B))", f"sqrt(1-B^2)"),\
                     (f"sin(arccos(B))", f"sqrt(1-B^2)"),\
-                    (f"arccos(B)", f"pi/2-arcsin(B)")]
+                    (f"arccos(B)", f"pi/2-arcsin(B)"),\
+                    (f"sin(arctan(B))", f"x/sqrt(1+x^2)"),\
+                    (f"cos(arctan(B))", f"1/sqrt(1+x^2)")]
     formula_list = [[simplify(parse(y)) for y in x] for x in formula_list]
     expr = [[parse("A"), parse("1")], [parse("B")], [parse("C"), parse("1")], [parse("D")]]
     return [formula_list, var, expr]
-formula_gen4 = trig_formula_init()
+#formula_gen4 = trig_formula_init()
 def trig3(eq):
     def iseven(eq):
         if eq.name[:2] != "d_":
@@ -145,15 +155,50 @@ def trig3(eq):
             eq = (eq.children[0]/2).fx("cos")**2-(eq.children[0]/2).fx("sin")**2
     eq = expand(simplify(eq))
     return TreeNode(eq.name, [trig3(child) for child in eq.children])
-def trig1(equation):
+def noneg_pow(eq):
+    if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1])<0:
+        return (eq.children[0]**(simplify(-eq.children[1])))**-1
+    return TreeNode(eq.name, [noneg_pow(child) for child in eq.children])
+def _trig1(equation):
     equation = product_to_sum(equation)
-    return TreeNode(equation.name, [trig1(child) for child in equation.children])
-def trig4(eq):
-    out = transform_formula(eq, "v_0", formula_gen4[0], formula_gen4[1], formula_gen4[2])
-    if out is not None:
-        return trig4(out)
-    else:
-        return TreeNode(eq.name, [trig4(child) for child in eq.children])
+    return TreeNode(equation.name, [_trig1(child) for child in equation.children])
+def trig1(eq):
+    return simplify(_trig1(noneg_pow(eq)))
+    
+def trig4(eq, numer=True):
+    if eq.name == "f_sin":
+        if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
+            r = len(eq.children[0].children)%2
+            a, b = eq.children[0].children[:(len(eq.children[0].children)-r)/2], eq.children[0].children[(len(eq.children[0].children)-r)/2:]
+            return a.fx("sin")*b.fx("cos") + a.fx("cos")*b.fx("sin")
+        if eq.children[0].name == "f_arccos":
+            a = eq.children[0].children[0]
+            return (1-a**2)**(tree_form("d_2")**-1)
+        if eq.children[0].name == "f_arctan":
+            a = eq.children[0].children[0]
+            return a/(1+a**2)**(tree_form("d_2")**-1)
+    if eq.name == "f_pow" and numer:
+        if eq.children[0].name == "f_cos":
+            a = eq.children[0].children[0]
+            if frac(eq.children[1]) == 2:
+                return 1 - a.fx("sin")**2
+        if eq.children[0].name == "f_sin":
+            a = eq.children[0].children[0]
+            if frac(eq.children[1]) == 2:
+                return 1 - a.fx("cos")**2
+    if eq.name == "f_cos":
+        if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
+            r = len(eq.children[0].children)%2
+            a, b = eq.children[0].children[:(len(eq.children[0].children)-r)/2], eq.children[0].children[(len(eq.children[0].children)-r)/2:]
+            return a.fx("cos")*b.fx("cos") - a.fx("sin")*b.fx("sin")
+        if eq.children[0].name == "f_arcsin":
+            a = eq.children[0].children[0]
+            return (1-a**2)**(tree_form("d_2")**-1)
+        if eq.children[0].name == "f_arctan":
+            a = eq.children[0].children[0]
+            return tree_form("d_1")/(1+a**2)**(tree_form("d_2")**-1)
+    
+    return TreeNode(eq.name, [trig4(child, False) if not numer or (eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) < 0) else trig4(child, True) for child in eq.children])
 def trig2(eq):
     if eq.name == "f_add":
         for item in itertools.combinations(range(len(eq.children)), 2):

{mathai-0.3.1.dist-info → mathai-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mathai
-Version: 0.3.1
+Version: 0.3.3
 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
@@ -69,22 +69,22 @@ f_add
 
 **Variables** (start with a `v_` prefix):
 
-- `v_0` → x
-- `v_1` → y
-- `v_2` → z
-- `v_3` → a
+- `v_0` -> x
+- `v_1` -> y
+- `v_2` -> z
+- `v_3` -> a
 
 **Numbers** (start with `d_` prefix; only integers):
 
-- `d_-1` → -1
-- `d_0` → 0
-- `d_1` → 1
-- `d_2` → 2
+- `d_-1` -> -1
+- `d_0` -> 0
+- `d_1` -> 1
+- `d_2` -> 2
 
 #### Branch Nodes
-- `f_add` → addition
-- `f_mul` → multiplication
-- `f_pow` → power
+- `f_add` -> addition
+- `f_mul` -> multiplication
+- `f_pow` -> power
 
 ### parse
 Takes a math equation string and outputs a `TreeNode` object.

mathai-0.3.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+mathai/__init__.py,sha256=GsDxDy6iWjoJ7CJty2nzE4Jx03mZkHFQW6hkmPJHkPE,1217
+mathai/apart.py,sha256=Fhl-OHZzPGIOj8YFyGQddjuh-2HV7uVDhkIzQ-YoMO0,3492
+mathai/base.py,sha256=x4Rjgz5mVblclsycKtDJjSudFpyIBWSEUX83_120BZY,12587
+mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
+mathai/diff.py,sha256=YUBpRsz0qmBkq5vGxeGnvR4nMKjdOQiIXlNMxpij2ns,3051
+mathai/expand.py,sha256=SnBltkpIENMGkP0AYmbMlSc4H-CF5RslO2PcBEkn1BQ,3359
+mathai/factor.py,sha256=NPXxET52TacNExuvw6p1jbC6g3wY6_VOCdlGlexXZio,5916
+mathai/fraction.py,sha256=Q2ztsh5Bpz6YhML2QU0tfufbAs0Q6J319AhlzKephIY,4396
+mathai/integrate.py,sha256=85qM7nvALtYjVMp17Tx5Kvevdz0d1UPDKQBBTnDqgrs,14828
+mathai/inverse.py,sha256=QCvDrzKquWsZv-BDAzZd9HnU0c3gZvcc44UztHVO5LQ,2919
+mathai/limit.py,sha256=RA8YAehgYCGVWv9qBc8uQ34BQ9mFthWl2OrVTwcHl2g,4920
+mathai/linear.py,sha256=wyiLpIxRDmD96xXktkgvc5gegIB3zblLB1EuV3TFdmU,5474
+mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
+mathai/parser.py,sha256=f7bemieFmp0sbup1NlraMLvZDVFvqKGFknEVtlFRMVk,6979
+mathai/printeq.py,sha256=gIes-pstFOa6FcnpVIVvkjVKuWdsVdo11LlEnmHhakU,1303
+mathai/search.py,sha256=BmUKacCpptIoyUObB0hknAbgFs8EPQXXXXYBXT40Luc,3672
+mathai/simplify.py,sha256=F37h-Z_rW35uVgx0G86vQErU2Ac6ZiTBN9KcC3RzDkg,15156
+mathai/structure.py,sha256=4Ww2IAx62RcQSO7_17TZES-DjMWBpcFQtL939FBIHwY,4103
+mathai/tool.py,sha256=UyccamiJy_CkFPakfufyPzdhtlEO6v2D7qwbXQ9V7Rg,2000
+mathai/trig.py,sha256=5P0RNS4eetNds2l-wyA4BAKqJdFIUws_8RGS_dH7gp8,9348
+mathai/univariate_inequality.py,sha256=_r-kkiS4Hr-jRN7f-EL_E4svAMFWJP1Ea50HJKKbjfk,14778
+mathai-0.3.3.dist-info/METADATA,sha256=mlSi3WdczR0cSSetNJUPeJE7v9EAHJY-wTjKFbvRtsg,7021
+mathai-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mathai-0.3.3.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.3.3.dist-info/RECORD,,

{mathai-0.3.1.dist-info → mathai-0.3.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

mathai-0.3.1.dist-info/RECORD

@@ -1,25 +0,0 @@
-mathai/__init__.py,sha256=OrSjLAAeRQrr4eHcOZFtU56gRIjukNKnsEaDnYiZjrk,649
-mathai/apart.py,sha256=P0B21wHUFitc5RGbNJlwSeOdseOMcav4I7teFNcZmFA,3130
-mathai/base.py,sha256=l8p8nkCuBDUISI5whtxIuZnOHyFn7F29mLXeKtWWWFQ,12392
-mathai/console.py,sha256=FsEMqDsgFeBSUiPCm9sfReZp56NSyoFVldqmVwvW4lg,3119
-mathai/diff.py,sha256=Dvc-tuiW8jLncybjGqHs2WTg2vpMEdRJqUoIdnDj4sk,2879
-mathai/expand.py,sha256=IqkxHS8lqbk0PZqz2y_IbRMSP0GExV6fneYwVEWQ9XM,1831
-mathai/factor.py,sha256=1-Bxl3MX6P1mYM-CX0hRskCrTZWHFdaUL-V1OqX48hY,5316
-mathai/fraction.py,sha256=KGldpi8mndp5cvp6qbN7ZdMZyVmK6popa3AwkWmHXl4,2573
-mathai/integrate.py,sha256=I_9hIi3m9eoYjYwBbp_Bu1VXVRiXbUqYcJfL3cpLBPk,12652
-mathai/inverse.py,sha256=QCvDrzKquWsZv-BDAzZd9HnU0c3gZvcc44UztHVO5LQ,2919
-mathai/limit.py,sha256=RA8YAehgYCGVWv9qBc8uQ34BQ9mFthWl2OrVTwcHl2g,4920
-mathai/linear.py,sha256=eVnDbJYC1TWwg4J7ovBKsaHYlSoDmXk5jQpsqwtVPyI,5481
-mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
-mathai/parser.py,sha256=aDaF1-tqJHZI4znAcHUSEbz7pPVnvHItOMZ2lp7Vxww,6940
-mathai/printeq.py,sha256=JTB0_RBcgt1yFviqlHtXGXuSXcpKrxzSxj5WHkOHon4,1318
-mathai/search.py,sha256=7YH39WN3pZsGdMfA-dXUSZalc0Orz3kI9fDLaegvV10,4617
-mathai/simplify.py,sha256=NymYVFocnpY8T-LJkyvQPddoF5avUgm3T-JzzRC1R3w,15040
-mathai/structure.py,sha256=Hgw2y43dwasa6G8z6OS2lmReh7JHwlChGn-FUdEaWY8,4106
-mathai/tool.py,sha256=87N5Ya7DmHdFOobTYDAjPHNWZuMzMIDjYN0ZtlHjxqE,1099
-mathai/trig.py,sha256=ywu89MJfAB81JCzsVPBLpGGv8od0LhLn5cgDtLtYwmw,6897
-mathai/univariate_inequality.py,sha256=_r-kkiS4Hr-jRN7f-EL_E4svAMFWJP1Ea50HJKKbjfk,14778
-mathai-0.3.1.dist-info/METADATA,sha256=hsbiZmYg6R_9C2NVmr7rh0g03RuOArr-CZ9r0WJQB80,7087
-mathai-0.3.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mathai-0.3.1.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.3.1.dist-info/RECORD,,