如何在Django中存储动态数学公式？含多元线性回归等复杂场景

Hey there! Let's break down your problem step by step—you're building a calculator that relies on dynamically updatable formulas (starting with polynomials like f = a0 + a1x + a2x², and eventually expanding to exponentials, sin/cos, etc.) with admin backend support, and need a solid way to model these formulas and store their coefficients. Here's what I recommend:

Forget trying to hardcode polynomial structures—Abstract Syntax Trees (ASTs) are the most flexible approach here, and they’ll scale seamlessly to complex functions down the line.

Here’s how it works:

• Any mathematical formula can be broken down into a tree of nodes, where each node represents an operation (addition, multiplication), a function (sin, exp), a variable (x), or a constant coefficient (a0, a1).
• For example, f = a0 + a1*x + a2*x² translates to this tree structure:

  Add
  ├─ Constant(a0)
  ├─ Add
     ├─ Multiply
        ├─ Constant(a1)
        └─ Variable(x)
     └─ Multiply
        ├─ Constant(a2)
        └─ Power
           ├─ Variable(x)
           └─ Constant(2)
  

• When you need to add sin(x) or exp(a3*x), you just add new node types (e.g., FunctionNode(name="sin", args=[Variable(x)]))—no major refactoring required.

You don’t need to build AST parsing/execution from scratch. These tools will handle the heavy lifting:

• Python: Use sympy for symbolic math operations—it can parse formula strings into ASTs, manipulate coefficients, and evaluate expressions. The built-in ast module works too if you want a lighter-weight option for parsing custom expression syntax.
• JavaScript: math.js or expr-eval let you parse and evaluate math expressions, and they support custom functions/variables out of the box.
• Java: Apache Commons Math has an ExpressionParser that can handle complex formulas and extract variables/coefficients.

All these libraries let you:

• Validate admin-input formulas (catch syntax errors before saving)
• Extract coefficients from formulas automatically
• Compile formulas into efficient executable functions for runtime calculations

To store formulas and their coefficients flexibly, use a two-table structure (adjust based on your tech stack):

formulas Table #

coefficients Table #

This setup lets admins:

• Update individual coefficients without modifying the entire formula structure
• Add new coefficients if they extend a formula (e.g., adding a3*exp(x) to an existing polynomial)
• Maintain clear visibility into both the formula structure and its parameters

When your calculator needs to compute a result:

1. Fetch the target formula’s serialized AST and its associated coefficients from the database.
2. Use your chosen library to hydrate the AST and inject the latest coefficient values.
3. Evaluate the AST with the input variable(s) (e.g., x=5) to get the result.

For better performance, you can compile the formula into a native function once (after fetching) instead of re-parsing it every time—most libraries support this.

As you expand to sin, cos, exponentials, or even custom functions, the AST approach scales effortlessly:

• When admins input a formula like f = a0 + a1*sin(a2*x) + a3*exp(x), your library will automatically parse the sin and exp calls into function nodes.
• You just need to ensure your database and AST serialization support these new node types (JSON works great here since it’s flexible).
• Add validation rules to restrict allowed functions if needed (e.g., prevent admins from using unsafe operations).

内容的提问来源于stack exchange，提问作者Ayoub Bani