feat: add math engine and puzzle services

2026-08-09 01:52:20 +08:00
parent 6bcff55c4f
commit b99a22fc06
21 changed files with 1011 additions and 1 deletions
@@ -0,0 +1,333 @@
+import ast
+import math
+from statistics import mean, median, pstdev, pvariance
+
+import sympy as sp
+from rest_framework.exceptions import ValidationError
+
+MAX_EXPRESSION_LENGTH = 500
+MAX_AST_NODES = 120
+MAX_MATRIX_CELLS = 36
+SYMBOLS = {name: sp.Symbol(name, real=True) for name in ("x", "y", "z", "a", "b", "t", "n")}
+CONSTANTS = {"pi": sp.pi, "e": sp.E, "E": sp.E, "i": sp.I, "I": sp.I}
+FUNCTIONS = {
+    "sin": sp.sin,
+    "cos": sp.cos,
+    "tan": sp.tan,
+    "asin": sp.asin,
+    "acos": sp.acos,
+    "atan": sp.atan,
+    "sinh": sp.sinh,
+    "cosh": sp.cosh,
+    "tanh": sp.tanh,
+    "sqrt": sp.sqrt,
+    "exp": sp.exp,
+    "ln": sp.log,
+    "log": sp.log,
+    "abs": sp.Abs,
+    "factorial": sp.factorial,
+    "binomial": sp.binomial,
+    "gcd": sp.gcd,
+    "lcm": sp.lcm,
+    "floor": sp.floor,
+    "ceil": sp.ceiling,
+}
+FUNCTION_ARITY = {
+    "factorial": (1, 1),
+    "binomial": (2, 2),
+    "gcd": (2, 2),
+    "lcm": (2, 2),
+}
+UNIT_FACTORS = {
+    "mm": ("length", 0.001),
+    "cm": ("length", 0.01),
+    "m": ("length", 1.0),
+    "km": ("length", 1000.0),
+    "in": ("length", 0.0254),
+    "ft": ("length", 0.3048),
+    "g": ("mass", 0.001),
+    "kg": ("mass", 1.0),
+    "lb": ("mass", 0.45359237),
+    "s": ("time", 1.0),
+    "min": ("time", 60.0),
+    "h": ("time", 3600.0),
+    "rad": ("angle", 1.0),
+    "deg": ("angle", math.pi / 180),
+}
+
+
+class SafeExpressionParser:
+    def __init__(self, source):
+        source = str(source or "").strip()
+        if not source:
+            raise ValidationError({"expression": "请输入数学表达式"})
+        if len(source) > MAX_EXPRESSION_LENGTH:
+            raise ValidationError({"expression": "表达式不能超过 500 个字符"})
+        source = (
+            source.replace("π", "pi")
+            .replace("×", "*")
+            .replace("÷", "/")
+            .replace("−", "-")
+            .replace("^", "**")
+        )
+        try:
+            self.tree = ast.parse(source, mode="eval")
+        except SyntaxError as exc:
+            raise ValidationError({"expression": "表达式语法无效"}) from exc
+        if sum(1 for _ in ast.walk(self.tree)) > MAX_AST_NODES:
+            raise ValidationError({"expression": "表达式过于复杂"})
+
+    def parse(self):
+        return self._convert(self.tree.body)
+
+    def _convert(self, node):
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, bool) or not isinstance(node.value, (int, float)):
+                raise ValidationError({"expression": "只允许数值常量"})
+            if isinstance(node.value, int) and len(str(abs(node.value))) > 50:
+                raise ValidationError({"expression": "整数位数过多"})
+            return sp.Integer(node.value) if isinstance(node.value, int) else sp.Float(node.value)
+        if isinstance(node, ast.Name):
+            if node.id in SYMBOLS:
+                return SYMBOLS[node.id]
+            if node.id in CONSTANTS:
+                return CONSTANTS[node.id]
+            raise ValidationError({"expression": f"不支持变量或常量 {node.id}"})
+        if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+            value = self._convert(node.operand)
+            return value if isinstance(node.op, ast.UAdd) else -value
+        if isinstance(node, ast.BinOp):
+            left = self._convert(node.left)
+            right = self._convert(node.right)
+            if isinstance(node.op, ast.Add):
+                return left + right
+            if isinstance(node.op, ast.Sub):
+                return left - right
+            if isinstance(node.op, ast.Mult):
+                return left * right
+            if isinstance(node.op, ast.Div):
+                return left / right
+            if isinstance(node.op, ast.Mod):
+                return sp.Mod(left, right)
+            if isinstance(node.op, ast.Pow):
+                if right.is_number and abs(float(right)) > 100:
+                    raise ValidationError({"expression": "幂指数绝对值不能超过 100"})
+                return left**right
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            function = FUNCTIONS.get(node.func.id)
+            if function is None:
+                raise ValidationError({"expression": f"不支持函数 {node.func.id}"})
+            minimum, maximum = FUNCTION_ARITY.get(node.func.id, (1, 2))
+            if node.keywords or not minimum <= len(node.args) <= maximum:
+                raise ValidationError({"expression": f"{node.func.id} 的参数数量无效"})
+            try:
+                return function(*(self._convert(item) for item in node.args))
+            except (TypeError, ValueError) as exc:
+                raise ValidationError({"expression": f"{node.func.id} 的参数无效"}) from exc
+        raise ValidationError({"expression": "表达式包含不允许的语法"})
+
+
+def parse_expression(source):
+    return SafeExpressionParser(source).parse()
+
+
+def parse_equation(source):
+    source = str(source or "")
+    if source.count("=") > 1:
+        raise ValidationError({"expression": "方程只能包含一个等号"})
+    if "=" not in source:
+        return parse_expression(source)
+    left, right = source.split("=", 1)
+    return sp.Eq(parse_expression(left), parse_expression(right))
+
+
+def serialize_math(value):
+    if isinstance(value, dict):
+        return {
+            str(serialize_math(key)["exact"]): serialize_math(item)
+            for key, item in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return [serialize_math(item) for item in value]
+    if isinstance(value, sp.MatrixBase):
+        return {
+            "exact": str(value.tolist()),
+            "decimal": str(value.evalf(12).tolist()),
+            "latex": sp.latex(value),
+        }
+    exact = str(value)
+    try:
+        decimal = str(sp.N(value, 12))
+    except Exception:
+        decimal = exact
+    return {"exact": exact, "decimal": decimal, "latex": sp.latex(value)}
+
+
+def parse_matrix(source):
+    rows = [row.strip() for row in str(source or "").split(";") if row.strip()]
+    if not rows:
+        raise ValidationError({"expression": "矩阵格式示例：1,2;3,4"})
+    parsed = [[parse_expression(cell.strip()) for cell in row.split(",")] for row in rows]
+    width = len(parsed[0])
+    if width == 0 or any(len(row) != width for row in parsed):
+        raise ValidationError({"expression": "矩阵每行列数必须一致"})
+    if len(parsed) * width > MAX_MATRIX_CELLS:
+        raise ValidationError({"expression": "矩阵最多支持 36 个元素"})
+    return sp.Matrix(parsed)
+
+
+def parse_number_list(source):
+    try:
+        values = [float(item.strip()) for item in str(source or "").split(",") if item.strip()]
+    except ValueError as exc:
+        raise ValidationError({"expression": "统计数据必须是逗号分隔的数字"}) from exc
+    if not 1 <= len(values) <= 500:
+        raise ValidationError({"expression": "统计数据数量必须在 1 到 500 之间"})
+    if not all(math.isfinite(item) for item in values):
+        raise ValidationError({"expression": "统计数据必须是有限数值"})
+    return values
+
+
+def calculate(payload):
+    operation = str(payload.get("operation", "calculate"))
+    source = payload.get("expression", "")
+    variable_name = str(payload.get("variable", "x"))
+    variable = SYMBOLS.get(variable_name)
+    if variable is None:
+        raise ValidationError({"variable": "变量仅支持 x、y、z、a、b、t、n"})
+
+    if operation == "statistics":
+        values = parse_number_list(source)
+        result = {
+            "count": len(values),
+            "mean": mean(values),
+            "median": median(values),
+            "variance": pvariance(values),
+            "standard_deviation": pstdev(values),
+            "minimum": min(values),
+            "maximum": max(values),
+        }
+        return {
+            "operation": operation,
+            "result": result,
+            "steps": ["读取数据", "计算集中趋势", "计算离散程度"],
+        }
+
+    if operation == "base":
+        try:
+            from_base = int(payload.get("from_base", 10))
+            to_base = int(payload.get("to_base", 2))
+            if not 2 <= from_base <= 36 or not 2 <= to_base <= 36:
+                raise ValueError
+            number = int(str(source).strip(), from_base)
+        except ValueError as exc:
+            raise ValidationError({"expression": "进制必须为 2 到 36，且输入应合法"}) from exc
+        digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        sign = "-" if number < 0 else ""
+        remaining = abs(number)
+        converted = "0"
+        if remaining:
+            pieces = []
+            while remaining:
+                remaining, index = divmod(remaining, to_base)
+                pieces.append(digits[index])
+            converted = "".join(reversed(pieces))
+        return {
+            "operation": operation,
+            "result": {"exact": f"{sign}{converted}", "decimal": str(number), "latex": sign + converted},
+            "steps": [f"按 {from_base} 进制读取", f"转换为 {to_base} 进制"],
+        }
+
+    if operation == "unit":
+        try:
+            value = float(str(source).strip())
+            from_unit = str(payload.get("from_unit", "m"))
+            to_unit = str(payload.get("to_unit", "cm"))
+            source_unit = UNIT_FACTORS[from_unit]
+            target_unit = UNIT_FACTORS[to_unit]
+            if source_unit[0] != target_unit[0] or not math.isfinite(value):
+                raise ValueError
+        except (KeyError, ValueError) as exc:
+            raise ValidationError({"expression": "单位不兼容或数值无效"}) from exc
+        converted = value * source_unit[1] / target_unit[1]
+        return {
+            "operation": operation,
+            "result": {
+                "exact": f"{converted:.12g} {to_unit}",
+                "decimal": f"{converted:.12g}",
+                "latex": f"{converted:.12g}\\,{to_unit}",
+            },
+            "steps": [f"将 {from_unit} 换算为标准单位", f"转换为 {to_unit}"],
+        }
+
+    if operation.startswith("matrix_"):
+        matrix = parse_matrix(source)
+        if operation == "matrix_det":
+            if not matrix.is_square:
+                raise ValidationError({"expression": "行列式要求方阵"})
+            result = matrix.det()
+            steps = ["读取矩阵", "按行列式规则计算"]
+        elif operation == "matrix_inverse":
+            if not matrix.is_square or matrix.det() == 0:
+                raise ValidationError({"expression": "矩阵不可逆"})
+            result = matrix.inv()
+            steps = ["读取矩阵", "验证行列式非零", "计算逆矩阵"]
+        elif operation == "matrix_rref":
+            result = matrix.rref()[0]
+            steps = ["读取矩阵", "执行初等行变换", "得到行最简形"]
+        elif operation == "matrix_transpose":
+            result = matrix.T
+            steps = ["读取矩阵", "交换行列"]
+        else:
+            raise ValidationError({"operation": "不支持的矩阵操作"})
+        return {"operation": operation, "result": serialize_math(result), "steps": steps}
+
+    expression = parse_equation(source) if operation == "solve" else parse_expression(source)
+    steps = ["解析受限数学表达式"]
+    if operation == "calculate":
+        result = sp.simplify(expression)
+        steps.append("化简并保留精确值")
+    elif operation == "simplify":
+        result = sp.trigsimp(sp.cancel(expression))
+        steps.append("约分并进行代数/三角化简")
+    elif operation == "expand":
+        result = sp.expand(expression)
+        steps.append("展开乘积与幂")
+    elif operation == "factor":
+        result = sp.factor(expression)
+        steps.append("提取因式并分解")
+    elif operation == "solve":
+        result = sp.solve(expression, variable)
+        if len(result) > 50:
+            raise ValidationError({"expression": "解的数量过多"})
+        steps.extend([f"以 {variable_name} 为未知量", "求解方程"])
+    elif operation == "derivative":
+        order = int(payload.get("order", 1))
+        if not 1 <= order <= 5:
+            raise ValidationError({"order": "导数阶数必须在 1 到 5 之间"})
+        result = sp.diff(expression, variable, order)
+        steps.append(f"对 {variable_name} 求 {order} 阶导数")
+    elif operation == "integral":
+        lower = str(payload.get("lower", "")).strip()
+        upper = str(payload.get("upper", "")).strip()
+        if lower or upper:
+            if not lower or not upper:
+                raise ValidationError({"bounds": "定积分必须同时填写上下限"})
+            result = sp.integrate(
+                expression,
+                (variable, parse_expression(lower), parse_expression(upper)),
+            )
+            steps.append(f"对 {variable_name} 计算定积分")
+        else:
+            result = sp.integrate(expression, variable)
+            steps.append(f"对 {variable_name} 计算不定积分")
+    elif operation == "limit":
+        point = parse_expression(payload.get("point", "0"))
+        direction = str(payload.get("direction", "+-"))
+        if direction not in {"+", "-", "+-"}:
+            raise ValidationError({"direction": "极限方向必须为 +、- 或 +-"})
+        result = sp.limit(expression, variable, point, dir=direction)
+        steps.append(f"令 {variable_name} 趋近 {point}")
+    else:
+        raise ValidationError({"operation": "不支持的计算类型"})
+    return {"operation": operation, "result": serialize_math(result), "steps": steps}