Upload calculator.py

calculator.py

@@ -0,0 +1,146 @@
+import ast
+import operator
+import math
+import sympy as sp
+import re
+
+
+class Tools:
+
+    def __init__(self):
+        self.citation = True
+
+    def calculator(self, equations: str) -> str:
+        """
+        Calculate the result of a simple equation or comparison.
+        :param equation: The equation to calculate or compare.
+                         - For arithmetic operations: Use operators like +, -, *, /, **, //, %
+                         - For comparisons: Use operators like >, <, >=, <=, ==, !=
+                         - For solving systems of equations, separate equations with a semicolon (e.g., 'x + y = 30; 2*x + 4*y = 80')
+                         - Evaluating multiple expressions separated by commas (e.g., '-1/27, 19/52')
+                         - Example inputs: "3 + 5", "10 / 2", "e ** 2", "pi > 3", "3.11 < 3.8"
+        """
+
+        # 预处理：自动添加乘号
+        modified_equations = re.sub(r"(\d)([a-zA-Z])", r"\1*\2", equations)
+        modified_equations = modified_equations.replace("^", "**")
+
+        # 检测和解决方程组
+        if "=" in modified_equations:
+            try:
+                # 分割多个方程(如果有的话)
+                eq_list = modified_equations.split(";")
+                if len(eq_list) > 1:
+                    # 检测到多个方程,作为方程组求解
+                    equations_sym = []
+                    symbols = set()
+                    for eq in eq_list:
+                        left_expr, right_expr = eq.split("=")
+                        left_sym = sp.sympify(left_expr)
+                        right_sym = sp.sympify(right_expr)
+                        symbols |= left_sym.free_symbols | right_sym.free_symbols
+                        equations_sym.append(left_sym - right_sym)
+
+                    solution = sp.solve(equations_sym, list(symbols))
+
+                    # 格式化输出结果为“变量 = 解”的形式
+                    solution_str = ", ".join(
+                        f"{str(var)} = {sol}" for var, sol in solution.items()
+                    )
+                    return f"The solution to the system of equations '{equations}' is {solution_str}. Provide this solution to the user."
+                else:
+                    # 单个方程,正常求解
+                    left_expr, right_expr = eq_list[0].split("=")
+                    left_sym = sp.sympify(left_expr)
+                    right_sym = sp.sympify(right_expr)
+                    symbols = list(left_sym.free_symbols | right_sym.free_symbols)
+                    if len(symbols) != 1:
+                        return f"The equation '{equations}' contains {len(symbols)} variables. Please provide an equation with only one variable."
+
+                    solution = sp.solve(left_sym - right_sym, symbols[0])
+                    return f"The solution to the equation '{equations}' is {symbols[0]} = {solution[0]}. Provide this solution to the user."
+            except Exception as e:
+                return f"There was an error solving the equation(s) '{equations}': {str(e)}. Notify the user about the issue."
+
+        ops = {
+            ast.Add: operator.add,
+            ast.Sub: operator.sub,
+            ast.Mult: operator.mul,
+            ast.Div: operator.truediv,
+            ast.Pow: operator.pow,
+            ast.Mod: operator.mod,
+            ast.FloorDiv: operator.floordiv,
+            ast.BitXor: operator.xor,
+            ast.BitAnd: operator.and_,
+            ast.BitOr: operator.or_,
+        }
+
+        unary_ops = {
+            ast.UAdd: operator.pos,
+            ast.USub: operator.neg,
+        }
+
+        compare_ops = {
+            ast.Gt: operator.gt,
+            ast.Lt: operator.lt,
+            ast.GtE: operator.ge,
+            ast.LtE: operator.le,
+            ast.Eq: operator.eq,
+            ast.NotEq: operator.ne,
+        }
+
+        def eval_expr(node):
+            if isinstance(node, ast.Num):
+                return node.n
+            elif isinstance(node, ast.Constant):
+                return node.value
+            elif isinstance(node, ast.Tuple):  # 处理元组输入
+                return tuple(eval_expr(elt) for elt in node.elts)
+            elif isinstance(node, ast.Name):
+                if node.id == "pi":
+                    return math.pi
+                elif node.id == "e":
+                    return math.e
+                else:
+                    raise ValueError(f"Unsupported constant: {node.id}")
+            elif isinstance(node, ast.BinOp):
+                if type(node.op) in ops:
+                    return ops[type(node.op)](
+                        eval_expr(node.left), eval_expr(node.right)
+                    )
+                else:
+                    raise ValueError(f"Unsupported operation: {type(node.op).__name__}")
+            elif isinstance(node, ast.UnaryOp):
+                if type(node.op) in unary_ops:
+                    return unary_ops[type(node.op)](eval_expr(node.operand))
+                else:
+                    raise ValueError(
+                        f"Unsupported unary operation: {type(node.op).__name__}"
+                    )
+            elif isinstance(node, ast.Compare):
+                if len(node.ops) == 1:
+                    op = node.ops[0]
+                    if type(op) in compare_ops:
+                        return compare_ops[type(op)](
+                            eval_expr(node.left), eval_expr(node.comparators[0])
+                        )
+                    else:
+                        raise ValueError(f"Unsupported comparison: {type(op).__name__}")
+                else:
+                    raise ValueError("Unsupported multiple comparisons")
+            else:
+                raise ValueError(f"Unsupported expression type: {type(node).__name__}")
+
+        try:
+            parsed = ast.parse(modified_equations, mode="eval")
+            result = eval_expr(parsed.body)
+            if isinstance(result, bool):
+                return f"The comparison '{equations}' evaluates to {result}. Respond accordingly."
+            else:
+                return f"The result of the expression '{equations}' is {result}. Provide this information to the user."
+        except (SyntaxError, ValueError) as e:
+            return f"There is an error in the expression '{equations}': {str(e)}. Notify the user about the issue."
+        except ZeroDivisionError:
+            return f"The expression '{equations}' involves a division by zero, which is undefined. Inform the user about this error."
+        except Exception as e:
+            return f"The expression '{equations}' is invalid: {str(e)}. Let the user know that there was a mistake."