From dcd0cdb8f751988aeb0ea1077262ce75f5652c6a Mon Sep 17 00:00:00 2001 From: cflmy Date: Wed, 5 Aug 2026 11:30:47 +0800 Subject: [PATCH] Add math stdlib with formulas/plots and polish the docs view. Ship Num/Formula runtime, bilingual math libs, SVG plots with axes/grid, and view UX for collapsible folders plus centered plots. Co-authored-by: Cursor --- doc/README.md | 2 +- doc/design/markdown-mapping.md | 1 + doc/design/stdlib-math.md | 294 +++++---- doc/design/stdlib-modules.md | 9 +- lib/math.mq.md | 200 ++++++ lib/数学.mq.md | 200 ++++++ public/README.md | 3 +- public/lib-import.mq.md | 13 - public/lib-导入.mq.md | 13 - public/stdlib/00-overview.mq.md | 2 +- public/stdlib/00-索引.mq.md | 2 +- public/stdlib/math.mq.md | 38 ++ public/stdlib/数学.mq.md | 38 ++ src/aliases.rs | 9 + src/ast.rs | 16 +- src/builtin.rs | 7 +- src/bytecode/compile.rs | 6 +- src/bytecode/vm.rs | 15 +- src/capture.rs | 2 + src/formula/mod.rs | 961 +++++++++++++++++++++++++++++ src/formula/plot.rs | 432 +++++++++++++ src/host/dispatch.rs | 246 +++++++- src/host/json.rs | 6 + src/host/math.rs | 284 +++++++++ src/host/mod.rs | 58 +- src/interp.rs | 18 +- src/lex/mod.rs | 53 +- src/lib.rs | 11 +- src/parse/mod.rs | 213 +++++-- src/value.rs | 15 +- src/view/html.rs | 213 +++++-- src/view/mod.rs | 31 +- src/view/output.rs | 1 + src/view/render.rs | 253 +++++++- tests/gold.rs | 57 ++ tests/lib/math-formula-chain.mq.md | 25 + tests/lib/math-formula.mq.md | 27 + tests/lib/math-plot.mq.md | 17 + tests/lib/math-random.mq.md | 22 + tests/lib/数学-数值.mq.md | 16 + 40 files changed, 3553 insertions(+), 276 deletions(-) create mode 100644 lib/math.mq.md create mode 100644 lib/数学.mq.md delete mode 100644 public/lib-import.mq.md delete mode 100644 public/lib-导入.mq.md create mode 100644 public/stdlib/math.mq.md create mode 100644 public/stdlib/数学.mq.md create mode 100644 src/formula/mod.rs create mode 100644 src/formula/plot.rs create mode 100644 src/host/math.rs create mode 100644 tests/lib/math-formula-chain.mq.md create mode 100644 tests/lib/math-formula.mq.md create mode 100644 tests/lib/math-plot.mq.md create mode 100644 tests/lib/math-random.mq.md create mode 100644 tests/lib/数学-数值.mq.md diff --git a/doc/README.md b/doc/README.md index f138af8..4b0dfab 100644 --- a/doc/README.md +++ b/doc/README.md @@ -27,7 +27,7 @@ | [design/stdlib.md](design/stdlib.md) | **P2 标准库:内置 + `lib/` + 错误约定** | | [design/stdlib-i18n.md](design/stdlib-i18n.md) | **标准库中英命名:靠库文件名区分,无 lang 开关** | | [design/stdlib-modules.md](design/stdlib-modules.md) | **本波 L1:文件/系统/时间/JSON/网络(JSON 中英同库)** | -| [design/stdlib-math.md](design/stdlib-math.md) | **暂缓:数学库(数值/符号/作图/`$$`)** | +| [design/stdlib-math.md](design/stdlib-math.md) | **方案:数学库(数值/随机/作图/轻量求解)** | | [design/stdlib-foreign.md](design/stdlib-foreign.md) | **暂缓:外联胶水(\`\`\`lang 具名块)** | | [design/call-arguments.md](design/call-arguments.md) | **调用:具名 + 位置实参** | | [design/examples-and-tests.md](design/examples-and-tests.md) | **tests/ 金样例目录布局** | diff --git a/doc/design/markdown-mapping.md b/doc/design/markdown-mapping.md index 77462ef..fba05ab 100644 --- a/doc/design/markdown-mapping.md +++ b/doc/design/markdown-mapping.md @@ -51,6 +51,7 @@ Markdown **标记即语法**。输出**不是**语言架构原语,而是内置 | `****` / `**` + 空白 + `**` | **空返回**(`None`),并结束本函数体 | | 无标记行 / 成段续行 | 注释(空行分段,见 §2) | | GFM 表格 | 集合 | +| 空 RHS 赋值 + 后随 `$$…$$`(或同行 `$$…$$`) | **公式赋值** → 运行时 `formula`(见 [stdlib-math.md](stdlib-math.md));叙述面无名 `$$` 仅展示 | | ` ```lang ` | 外联异种代码 | | 函数体内 `---` / `***` | **结束本函数体**(无返回值函数的收束;见 §11) | diff --git a/doc/design/stdlib-math.md b/doc/design/stdlib-math.md index 91e9fb9..be014a7 100644 --- a/doc/design/stdlib-math.md +++ b/doc/design/stdlib-math.md @@ -1,181 +1,231 @@ -# 数学标准库(候选) +# 数学标准库(方案) | | | |---|---| -| 状态 | **草案 / 暂缓**(本波不实现;五库之后再议) | +| 状态 | **已实现(M1–M4)** | | 日期 | 2026-08-05 | -| 相关 | [stdlib-modules.md](stdlib-modules.md) · [stdlib-i18n.md](stdlib-i18n.md) · [view.md](view.md) · [markdown-mapping.md](markdown-mapping.md) | -| 灵感 | Markdown `$$…$$` / `$…$` 公式面;文档即计算笔记本 | +| 相关 | [stdlib-modules.md](stdlib-modules.md) · [stdlib-i18n.md](stdlib-i18n.md) · [markdown-mapping.md](markdown-mapping.md) · [view.md](view.md) | +| 导入 | `lib/math.mq.md`(英)· `lib/数学.mq.md`(中) | +| 范围 | **高中数学**(初等函数、导数、圆锥曲线、简单方程);非大学 CAS | --- -## 1. 为什么值得做 +## 1. 目标 -Markdown 读者已习惯用 `$$` 写公式。若 Marqdo 能: +1. **公式类型**:解析 `$$…$$`(及行内 `$…$` 的可选支持),得到可绑定、可传递的 **`formula` 值**——语义上像「公式常量 / 公式变量」。 +2. **数学库对 `formula`(及文本表达式)做操作**:求值、化简、求导、求解、作图等。 +3. **数值 + 随机**:日常算术与可复现随机。 +4. **作图**:view / 静态页内嵌 SVG;CLI 写本地文件(可指定 `path`)。 -1. **认出**文档中的公式(或显式传入 LaTeX/ASCII-math 字符串); -2. **符号整理 / 求值 / 求解**; -3. 在 **`marqdo view` 里画出**简单图像; - -则同一份 `.mq.md` 既是讲义又是可运行实验,差异化远大于「再包一层 `sin`」。 - -风险同样大:CAS、数值稳定、渲染栈都会显著增加依赖与维护面。故标为**候选**:先定分层,允许只实现「数值 + 显式字符串」,再渐进接 `$$`。 +**难度自觉:** 只覆盖高中知识面,自研小型表达式 AST + 规则即可,**不**追求 Mathematica / SymPy 完备性。 --- -## 2. 产品分层(建议) +## 2. 核心模型:`formula` 类型 -| 层 | 能力 | 依赖量 | 建议阶段 | -|----|------|--------|----------| -| **Math-N(数值)** | 四则、幂、根、三角函数、常数;列表上的 map 式计算 | 小(可纯 Rust) | 若纳入官方库,**先做这层** | -| **Math-S(符号)** | 化简、展开、求导、代入、解方程(单变元优先) | 中–大(自研子集或嵌 CAS) | 第二期 | -| **Math-P(作图)** | 把表达式/点列渲染为 SVG(或 PNG)嵌入 view | 中(SVG 即可) | 与 view 同期 | -| **Math-D(文档公式)** | 解析正文 `$$…$$`,命名后供调用 | 中(词法/源映射) | 第三期 | +### 2.1 运行时 -**默认发版建议:** 官方 `lib/math` 先只承诺 **Math-N**;S/P/D 放 `experimental` 或 feature `math-cas` / `math-plot`,避免「标准库」名不副实。 +| 类型 | `type` 标签 | 说明 | +|------|-------------|------| +| `Value::Num(f64)` | `num` | 浮点 | +| `Value::Formula(…)` | `formula` | 已解析的表达式树(或等价内部表示) | ---- +`print` / `str` 对 `formula`:输出规范 ASCII(如 `2*x + 1`)或保留源 LaTeX 的一种(实现时写死并文档化;建议 **ASCII 规范式** 便于测试)。 -## 3. 导入与命名 +### 2.2 文档中的 `$$` = 公式赋值(与表格同构) -| 导入 | API 语言 | -|------|----------| -| `> lib/math.mq.md` | 英文 | -| `> lib/数学.mq.md` | 中文 | +在可执行面用 **空 RHS 赋值** 后跟展示数学块,把公式绑到变量(与 `` `xs` = `` 后跟表格一致): -宿主原语(L0.5)示例:`math_sin`、`math_eval`、`math_solve` —— 仅供库包装。 +````markdown +# main ---- +`f` = +$$ +sin(x) + x +$$ -## 4. 用户 API 草图 +*`df` = > diff formula=`f` var=x * -### 4.1 数值(Math-N) +> plot formula=`f` var=x min=-3 max=3 path=f.svg +```` + +也支持: + +- 单行围栏:下一行 `$$x^2 - 2$$` +- 同行 compact:`*`f` = $$x^2 - 2$$ *` + +**废除:** `$$:name` / `$$ name=…` 模块级具名块(不再产生绑定)。 + +**无名 `$$…$$`:** 仅在成段注释(叙述面)里作展示,**不**进入运行时。可执行区若出现未挂在赋值上的裸 `$$` 围栏 → 报错,提示使用 `` `name` = `` + 围栏。 + +**行内 `$…$`:** v1 不做绑定;需要时用 `> formula text=…` 显式构造。 + +### 2.3 从文本构造 | 英文 | 中文 | 说明 | |------|------|------| -| `pi` / `e` | `圆周率` / `自然底数` | 无参,返回文本或「十进制文本」——**本波仍无 float 类型时用文本十进制**,或引入 `num` 宿主类型 | -| `add` `sub` `mul` `div` `pow` `sqrt` | `加` `减` `乘` `除` `幂` `根` | | -| `sin` `cos` `tan` `ln` `exp` | `正弦` `余弦` `正切` `对数` `指数` | 弧度 | -| `round` `floor` `ceil` | `四舍` `向下` `向上` | | -| `eval_num` | `求值` | `expr` 文本 → 数值文本 | +| `formula` | `公式` | `text=` 解析为 `formula`(ASCII 或简单 LaTeX 子集) | -**类型抉择(必须先 ADR):** +数学库函数形参统一接受:**`formula` 值**,或能解析的 **文本**(内部先 `formula` 化)。 -| 选项 | 优点 | 缺点 | +### 2.4 与叙述面的关系 + +- `` `f` = `` + `$$…$$`:代码面赋值,得到 `formula` 值。 +- 成段注释里的 `$$`:仍是注释,不解析为公式。 +- view:公式赋值在 Structure 中显示为绑定,不是 comment。 + +(见 [markdown-mapping.md](markdown-mapping.md):空 RHS + `$$` → 公式赋值。) + +--- + +## 3. 知识范围(高中) + +### 3.1 表达式与符号(S) + +| 纳入 | 例子 | +|------|------| +| 多项式 | `x^2 - 3*x + 2` | +| 初等函数 | `sin` `cos` `tan` `ln` `exp` `sqrt` `abs` | +| 四则、幂 | `+ - * / ^` | +| 化简 / 展开 | 合并同类项、基本三角恒等(小集合) | +| 求导 | 单变元,初等函数求导法则 | +| 代入求值 | `subs` → `num` 或公式 | +| 求解 | 一元一次 / 二次闭式;其它用数值求根并标明 | + +**不做(本波):** 多元方程组、极限 ε-δ、级数、积分保证、矩阵、复数完备、任意证明。 + +### 3.2 作图(P) + +| 纳入 | 说明 | +|------|------| +| 显函数 `y=f(x)` | 采样折线 SVG | +| 导数曲线 | 对 `formula` 先 `diff` 再画,或 `plot` 选项 `derivative=true` | +| 圆锥曲线 | 标准形:圆、椭圆、双曲线、抛物线(参数方程或隐式采样) | +| 点列 | `plot_points` | + +**不做:** 三维、隐函数通用求解器、交互缩放(静态 SVG 足够)。 + +### 3.3 数值与随机(N) + +常数、四则、三角、对数、取整、`num` 转换、`random` / `random_int` / `seed`(同前稿)。 + +--- + +## 4. API 草图(对 `formula` 操作) + +### 4.1 构造与数值 + +| 英文 | 中文 | 要点 | |------|------|------| -| A. 继续只用 `int` + 十进制 `text` | 不碰 L0 | 慢、易错 | -| B. 新增宿主 `num`(十进制或 f64) | API 干净 | 类型与字节码要跟进 | -| C. 数学库内部不透明 `handle` | 隔离好 | 与 `print`/`json` 互通差 | +| `formula` | `公式` | 文本 → formula | +| `pi` `e` | `圆周率` `自然底数` | → num | +| `add`… / `sin`… | `加`… / `正弦`… | 对 num;若传入 formula 则返回 formula(符号)或报错——**v1 建议:算术函数只接 num;符号用 simplify/diff/subs** | +| `eval` | `求值` | `formula` + 变量赋值 → num | +| `random` / `random_int` / `seed` | `随机` / `随机整数` / `设种子` | 见前 | -倾向:**B(`num`)**,与 JSON 的非整数数字策略一并设计。 - -### 4.2 符号(Math-S) +### 4.2 符号 | 英文 | 中文 | 形参 | 结果 | |------|------|------|------| -| `simplify` | `化简` | `expr` | 表达式文本(或 handle) | -| `expand` | `展开` | `expr` | 同上 | -| `diff` | `求导` | `expr`, `var` | 同上 | -| `subs` | `代入` | `expr`, `var`, `value` | 同上 | -| `solve` | `求解` | `expr`, `var` | 解列表(文本) | +| `simplify` | `化简` | `formula` | formula | +| `expand` | `展开` | `formula` | formula | +| `diff` | `求导` | `formula`, `var` | formula | +| `subs` | `代入` | `formula`, `var`, `value` | formula 或 num | +| `solve` | `求解` | `formula`, `var`,可选区间 | list(num 或公式根) | -表达式互换格式(草案):**ASCII 优先**(`2*x^2 + 1`),LaTeX 作为可选输入 `format=latex`。 +### 4.3 作图 -单变元多项式 / 简单超越方程为 v1 目标;多变元方程组、积分:**不做承诺**。 - -### 4.3 作图(Math-P) - -| 英文 | 中文 | 说明 | +| 英文 | 中文 | 形参 | |------|------|------| -| `plot_fn` | `绘函数` | `expr`, `var`, `min`, `max`, 可选 `steps` → **SVG 文本** | -| `plot_points` | `绘点列` | `xs`, `ys` → SVG 文本 | +| `plot` | `绘图` | **`formula`**(或 `expr` 文本), `var`, `min`, `max`;可选 `steps`, `path`, `derivative`, **`grid`**(默认开;`False`/`假` 关) | +| `plot_conic` | `绘圆锥` | `kind`(circle/ellipse/hyperbola/parabola)+ 系数;可选 `path`, `grid` | +| `plot_points` | `绘点列` | `xs`, `ys`;可选 `path`, `grid` | -view 行为: +返回 **SVG 文本**;坐标轴带箭头与刻度,默认网格;写文件与 view 嵌入规则同前(§5)。 -- 若 stdout / 返回值为「带标记的 SVG」或约定 MIME,Execution 区**内嵌渲染**(非仅 `
`)。  
-- 静态 `view output`:把 SVG 写入 HTML。  
-- CLI:默认打印 SVG 文本;`--plot-file out.svg` 可选。
+`diff` / `simplify` / `expand` / 未完全数值化的 `subs` 返回 **`formula`**,可继续链式调用。
 
-不引入完整浏览器 Chart 框架;**SVG 路径足够**教微积分与拟合入门。
+示例:
 
-### 4.4 文档公式面(Math-D)
+```markdown
+# main
 
-与 [markdown-mapping.md](markdown-mapping.md) 的衔接:
+`f` =
+$$
+x^2 - 2
+$$
 
-| 现状 | 目标 |
+*`roots` = > solve formula=`f` var=x *
+
+> print text=`roots`
+
+*`svg` = > plot formula=`f` var=x min=-3 max=3 path=parabola.svg *
+```
+
+---
+
+## 5. 作图:CLI / view / 静态(不变精神)
+
+| 场景 | 行为 |
 |------|------|
-| `$$` 多半落入叙述/未定义 | 可选:**命名公式块**可被引用 |
+| 带 `path=` | 写 SVG 到该路径(沙箱内) |
+| CLI 无 path | 自动 `{stem}-plot-{n}.svg` + 一行 `plot: …` |
+| view / 导出无 path | 不强制写盘;加入 **plots 产物列表**,Execution 内嵌 |
+| view / 导出有 path | 写盘 + 内嵌 |
 
-建议语法(草案,需进 mapping 修订):
-
-```markdown
-$$:energy
-E = mc^2
-$$
-```
-
-或 frontmatter / 标题锚定:
-
-```markdown
-## energy
-$$
-E = mc^2
-$$
-```
-
-调用:
-
-```markdown
----`
-> lib/math.mq.md
----`
-
-*`e2` = > simplify expr=> formula name=energy *
-```
-
-更简单的 v1:**不解析正文 `$$`**,只接受:
-
-```markdown
-*`e2` = > simplify expr=E=mc^2 format=latex *
-```
-
-正文 `$$` 仍由 view 的 Markdown 渲染(KaTeX/MathJax)负责「好看」,计算走显式字符串——**降低词法耦合**,推荐作为第一刀。
+不把整段 SVG 默认灌进 CLI stdout。
 
 ---
 
-## 5. 实现策略选项
+## 6. 分期
 
-| 策略 | 说明 | 建议 |
-|------|------|------|
-| **纯 Rust 数值** | `libm` / 自写 | Math-N 必选 |
-| **嵌入轻量 CAS** | 如符号子集自研,或绑 `meval`/`fasteval` 仅数值 | 求值用 |
-| **外挂 SymPy(经外联库)** | 符号交给 Python | 与 [stdlib-foreign.md](stdlib-foreign.md) 合流;标准库变薄 |
-| **WASM CAS** | 可嵌入 view | 后期 |
+| 期 | 交付 |
+|----|------|
+| **M1** | `Num` + 数值/随机;`Formula` AST + `` `name` = `` + `$$…$$` 赋值绑定 |
+| **M2** | `simplify` / `diff` / `subs` / `eval` / 二次 `solve`(高中子集) |
+| **M3** | `plot` / `plot_points` / `plot_conic` + view 内嵌 + path 写盘 |
+| **M4** | 用户文档 `public/stdlib/math*` · 金样例 · mapping 文档补丁 |
 
-务实路径:**Math-N 自研 → Math-P SVG → Math-S 先外联 SymPy(可选)→ 再考虑内嵌**。这样「数学标准库」在官方包里可以很瘦,重能力走外联 feature。
+M1–M3 可在同一发版列车上连续落地;验收以「公式赋值 → 求导 → 作图」一条龙为准。
 
 ---
 
-## 6. 安全与性能
+## 7. 实现要点
 
-- 表达式长度、求解迭代、绘图采样点设硬上限。  
-- 禁止公式里跑任意宿主代码(与外联分离)。  
-- view 中绘图同步、限时。
+```text
+src/formula/          # 词法/AST/化简/求导/求值(高中规则表)
+src/host/math.rs      # 数值、随机、对 formula 的 host 入口
+src/host/plot.rs      # SVG
+lex/parse:空 RHS 赋值 + $$ 围栏 → Expr::Formula
+Value::Num / Value::Formula
+Interpreter.plots: Vec
+lib/math.mq.md · lib/数学.mq.md
+```
+
+依赖:纯 Rust;不绑 SymPy。公式复杂度、采样点、SVG 大小设硬上限。
 
 ---
 
-## 7. 是否定为「标准库」的决策标准
+## 8. 刻意不做
 
-纳入默认 `lib/math` 当且仅当:
-
-1. Math-N API 稳定且有中英金样例;  
-2. 不强制下载数百 MB 依赖;  
-3. 无外联时文档站示例仍可跑(纯数值 + 可选 SVG)。
-
-若符号/作图依赖 SymPy 或大型引擎 → 标 **`lib/math` = 数值**,符号示例放到 `examples/math-cas` 并要求 `--allow-foreign`。
+- `$$:name` 模块级具名绑定(已废除)。  
+- 无名 `$$` 自动进运行时。  
+- 大学级数 / 完备积分 / 定理证明。  
+- 通用隐函数作图引擎。  
+- 3D、交互式图表库。
 
 ---
 
-## 8. 一句话
+## 9. 验收
 
-**用 Markdown 的公式习惯服务「可计算文档」;官方数学库先数值与 SVG,符号与 `$$` 引用分期,必要时借外联而非做大内核。**
+1. `` `f` = `` + `$$…$$` + `diff` / `solve` / `plot` 金样例(中英库)。  
+2. 固定 `seed` 的随机金样例。  
+3. `plot` + `path` 在 CLI 落盘;view HTML 含 ` host_pi**
+
+# e
+
+**> host_e**
+
+# num
+    - value
+
+**> host_num value=`value`**
+
+# add
+    - a
+    - b
+
+**> host_math_add a=`a` b=`b`**
+
+# sub
+    - a
+    - b
+
+**> host_math_sub a=`a` b=`b`**
+
+# mul
+    - a
+    - b
+
+**> host_math_mul a=`a` b=`b`**
+
+# div
+    - a
+    - b
+
+**> host_math_div a=`a` b=`b`**
+
+# pow
+    - a
+    - b
+
+**> host_math_pow a=`a` b=`b`**
+
+# neg
+    - value
+
+**> host_math_neg value=`value`**
+
+# sin
+    - value
+
+**> host_math_sin value=`value`**
+
+# cos
+    - value
+
+**> host_math_cos value=`value`**
+
+# tan
+    - value
+
+**> host_math_tan value=`value`**
+
+# asin
+    - value
+
+**> host_math_asin value=`value`**
+
+# acos
+    - value
+
+**> host_math_acos value=`value`**
+
+# atan
+    - value
+
+**> host_math_atan value=`value`**
+
+# sqrt
+    - value
+
+**> host_math_sqrt value=`value`**
+
+# abs
+    - value
+
+**> host_math_abs value=`value`**
+
+# ln
+    - value
+
+**> host_math_ln value=`value`**
+
+# exp
+    - value
+
+**> host_math_exp value=`value`**
+
+# floor
+    - value
+
+**> host_math_floor value=`value`**
+
+# ceil
+    - value
+
+**> host_math_ceil value=`value`**
+
+# min
+    - a
+    - b
+
+**> host_math_min a=`a` b=`b`**
+
+# max
+    - a
+    - b
+
+**> host_math_max a=`a` b=`b`**
+
+# random
+
+**> host_random**
+
+# random_int
+    - min
+    - max
+
+**> host_random_int min=`min` max=`max`**
+
+# seed
+    - value
+
+**> host_seed value=`value`**
+
+# formula
+    - text
+
+**> host_formula value=`text`**
+
+# simplify
+    - formula
+
+**> host_simplify value=`formula`**
+
+# expand
+    - formula
+
+**> host_expand value=`formula`**
+
+# diff
+    - formula
+    - var
+
+**> host_diff formula=`formula` var=`var`**
+
+# subs
+    - formula
+    - var
+    - value
+
+**> host_subs formula=`formula` var=`var` value=`value`**
+
+# eval
+    - formula
+    - var
+    - value
+
+**> host_eval formula=`formula` var=`var` value=`value`**
+
+# solve
+    - formula
+    - var
+
+**> host_solve formula=`formula` var=`var`**
+
+# plot
+    - formula
+    - var
+    - min
+    - max
+
+**> host_plot formula=`formula` var=`var` min=`min` max=`max`**
+
+# plot_points
+    - xs
+    - ys
+
+**> host_plot_points xs=`xs` ys=`ys`**
+
+# plot_conic
+    - kind
+    - a
+
+**> host_plot_conic kind=`kind` a=`a`**
diff --git a/lib/数学.mq.md b/lib/数学.mq.md
new file mode 100644
index 0000000..1ab4574
--- /dev/null
+++ b/lib/数学.mq.md
@@ -0,0 +1,200 @@
+---
+title: lib/数学
+description: 高中数学 — 数值、随机、公式、作图
+---
+
+# 圆周率
+
+**> host_pi**
+
+# 自然底数
+
+**> host_e**
+
+# 数
+    - value
+
+**> host_num value=`value`**
+
+# 加
+    - a
+    - b
+
+**> host_math_add a=`a` b=`b`**
+
+# 减
+    - a
+    - b
+
+**> host_math_sub a=`a` b=`b`**
+
+# 乘
+    - a
+    - b
+
+**> host_math_mul a=`a` b=`b`**
+
+# 除
+    - a
+    - b
+
+**> host_math_div a=`a` b=`b`**
+
+# 幂
+    - a
+    - b
+
+**> host_math_pow a=`a` b=`b`**
+
+# 负
+    - value
+
+**> host_math_neg value=`value`**
+
+# 正弦
+    - value
+
+**> host_math_sin value=`value`**
+
+# 余弦
+    - value
+
+**> host_math_cos value=`value`**
+
+# 正切
+    - value
+
+**> host_math_tan value=`value`**
+
+# 反正弦
+    - value
+
+**> host_math_asin value=`value`**
+
+# 反余弦
+    - value
+
+**> host_math_acos value=`value`**
+
+# 反正切
+    - value
+
+**> host_math_atan value=`value`**
+
+# 平方根
+    - value
+
+**> host_math_sqrt value=`value`**
+
+# 绝对值
+    - value
+
+**> host_math_abs value=`value`**
+
+# 对数
+    - value
+
+**> host_math_ln value=`value`**
+
+# 指数
+    - value
+
+**> host_math_exp value=`value`**
+
+# 向下取整
+    - value
+
+**> host_math_floor value=`value`**
+
+# 向上取整
+    - value
+
+**> host_math_ceil value=`value`**
+
+# 最小
+    - a
+    - b
+
+**> host_math_min a=`a` b=`b`**
+
+# 最大
+    - a
+    - b
+
+**> host_math_max a=`a` b=`b`**
+
+# 随机
+
+**> host_random**
+
+# 随机整数
+    - min
+    - max
+
+**> host_random_int min=`min` max=`max`**
+
+# 设种子
+    - value
+
+**> host_seed value=`value`**
+
+# 公式
+    - text
+
+**> host_formula value=`text`**
+
+# 化简
+    - formula
+
+**> host_simplify value=`formula`**
+
+# 展开
+    - formula
+
+**> host_expand value=`formula`**
+
+# 求导
+    - formula
+    - var
+
+**> host_diff formula=`formula` var=`var`**
+
+# 代入
+    - formula
+    - var
+    - value
+
+**> host_subs formula=`formula` var=`var` value=`value`**
+
+# 求值
+    - formula
+    - var
+    - value
+
+**> host_eval formula=`formula` var=`var` value=`value`**
+
+# 求解
+    - formula
+    - var
+
+**> host_solve formula=`formula` var=`var`**
+
+# 绘图
+    - formula
+    - var
+    - min
+    - max
+
+**> host_plot formula=`formula` var=`var` min=`min` max=`max`**
+
+# 绘点列
+    - xs
+    - ys
+
+**> host_plot_points xs=`xs` ys=`ys`**
+
+# 绘圆锥
+    - kind
+    - a
+
+**> host_plot_conic kind=`kind` a=`a`**
diff --git a/public/README.md b/public/README.md
index f1d8264..09090f9 100644
--- a/public/README.md
+++ b/public/README.md
@@ -9,9 +9,8 @@
 | [`00-welcome.mq.md`](00-welcome.mq.md) / [`00-欢迎.mq.md`](00-欢迎.mq.md) | 首页(英 / 中) |
 | [`structure/`](structure/) | 基本结构 |
 | [`keywords/`](keywords/) | 关键字与 L0 内置 |
-| [`stdlib/`](stdlib/) | **标准库**(导入方式 + text/表/文件/时间/系统/json/网络) |
+| [`stdlib/`](stdlib/) | **标准库**(导入方式 + text/表/文件/时间/系统/json/网络/数学) |
 | [`features/`](features/) | 特性迭代 |
-| [`lib-import.mq.md`](lib-import.mq.md) / [`lib-导入.mq.md`](lib-导入.mq.md) | 快速导入示例(text) |
 
 **不放** `errors/`:失败样例只在 `tests/errors/`。
 
diff --git a/public/lib-import.mq.md b/public/lib-import.mq.md
deleted file mode 100644
index 32c31b8..0000000
--- a/public/lib-import.mq.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Import official lib
-description: Frontmatter `lib/…` or `std/…`
-> lib/text.mq.md
----
-
-# main
-
-After importing `lib/text.mq.md`, call the English wrappers:
-
-*`t` = > str_trim s=  marqdo  *
-
-> print text=`t`
diff --git a/public/lib-导入.mq.md b/public/lib-导入.mq.md
deleted file mode 100644
index ae21ef3..0000000
--- a/public/lib-导入.mq.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: 导入官方库
-description: frontmatter 使用 lib/… 或 std/…
-> lib/文本.mq.md
----
-
-# main
-
-导入 `lib/文本.mq.md` 后可调用中文包装函数:
-
-*`t` = > 去空白 s=  marqdo  *
-
-> 打印 内容=`t`
diff --git a/public/stdlib/00-overview.mq.md b/public/stdlib/00-overview.mq.md
index e968588..9a53590 100644
--- a/public/stdlib/00-overview.mq.md
+++ b/public/stdlib/00-overview.mq.md
@@ -11,7 +11,7 @@ English-named files export English APIs; Chinese-named files export Chinese APIs
 
 No extra allow flags: importing a module means you intend to use it. Under marqdo view or static export, exit soft-fails and long sleeps are clamped so the console stays up.
 
-Modules: text (text / 文本), table (table / 表), files (fs / 文件), time (time / 时间), system (sys / 系统), json (json only), net (net / 网络).
+Modules: text (text / 文本), table (table / 表), files (fs / 文件), time (time / 时间), system (sys / 系统), json (json only), net (net / 网络), math (math / 数学).
 
 Sibling pages in this folder document each module. Chinese overview: 00-索引.mq.md.
 
diff --git a/public/stdlib/00-索引.mq.md b/public/stdlib/00-索引.mq.md
index e36ebef..0858eb8 100644
--- a/public/stdlib/00-索引.mq.md
+++ b/public/stdlib/00-索引.mq.md
@@ -11,7 +11,7 @@ description: 如何导入官方 lib 模块
 
 导入即表示要用对应能力,无需再加允许旗标。marqdo view 或静态导出里,退出会软失败、长睡眠会被钳制,以免拖垮控制台。
 
-模块:文本(text / 文本)、表(table / 表)、文件(fs / 文件)、时间(time / 时间)、系统(sys / 系统)、json(仅 json)、网络(net / 网络)。
+模块:文本(text / 文本)、表(table / 表)、文件(fs / 文件)、时间(time / 时间)、系统(sys / 系统)、json(仅 json)、网络(net / 网络)、数学(math / 数学)。
 
 各模块说明见本目录其它页。English: 00-overview.mq.md.
 
diff --git a/public/stdlib/math.mq.md b/public/stdlib/math.mq.md
new file mode 100644
index 0000000..135a687
--- /dev/null
+++ b/public/stdlib/math.mq.md
@@ -0,0 +1,38 @@
+---
+title: lib/math — numbers, formulas, plots
+description: High-school math stdlib (English)
+> lib/math.mq.md
+---
+
+# main
+
+Import lib/math.mq.md. Runtime types: num (float) and formula (symbolic tree). Bind a formula with an empty-RHS assign followed by a `$$…$$` fence (same shape as table assigns). In view, Structure renders that fence with KaTeX.
+
+`f` =
+$$
+x^2 - 2
+$$
+
+Numeric helpers: pi, e, num, add/sub/mul/div/pow, sin/cos/tan, sqrt/abs/ln/exp, floor/ceil, min/max. Random: seed, random, random_int (reproducible after seed).
+
+Symbolic: formula(text), simplify, expand, diff, subs, eval, solve.
+
+Plotting (already in the library): plot / plot_points / plot_conic return SVG text. Axes include arrows and tick labels; **grid is on by default** (pass grid=False / grid=假 to hide). Optional path= writes a file under the sandbox. With no path, CLI auto-writes stem-plot-n.svg and prints plot: …; view embeds the SVG under Execution.
+
+diff / simplify / expand / partial subs return formula values so you can chain (e.g. differentiate twice, then plot or eval).
+
+*`ty` = > type `f` *
+
+> print text=`ty`
+
+*`df` = > diff formula=`f` var=x *
+
+> print text=`df`
+
+*`roots` = > solve formula=`f` var=x *
+
+> print text=`roots`
+
+*`_svg` = > plot formula=`f` var=x min=-3 max=3 *
+
+> print text=plot-ok
diff --git a/public/stdlib/数学.mq.md b/public/stdlib/数学.mq.md
new file mode 100644
index 0000000..b18367f
--- /dev/null
+++ b/public/stdlib/数学.mq.md
@@ -0,0 +1,38 @@
+---
+title: lib/数学 — 数值、公式、作图
+description: 高中数学标准库(中文)
+> lib/数学.mq.md
+---
+
+# main
+
+导入 lib/数学.mq.md。运行时类型:num(浮点)与 formula(符号树)。用空 RHS 赋值后跟 `$$…$$` 围栏绑定公式(与表格赋值同构)。view 的 Structure 会用 KaTeX 渲染该公式。
+
+`f` =
+$$
+x^2 - 2
+$$
+
+数值:圆周率、自然底数、数、加/减/乘/除/幂、正弦/余弦/正切、平方根/绝对值/对数/指数、向下取整/向上取整、最小/最大。随机:设种子、随机、随机整数。
+
+符号:公式、化简、展开、求导、代入、求值、求解。
+
+作图(库已提供):绘图 / 绘点列 / 绘圆锥,返回 SVG 文本。坐标轴带箭头与刻度;**默认显示网格**(`grid=假` 可关闭)。可选 path= 写盘。无 path 时 CLI 自动写 stem-plot-n.svg 并打印 plot: …;view 在 Execution 内嵌 SVG。
+
+求导 / 化简 / 展开 / 未完全数值化的代入仍返回 formula,可继续链式调用(例如求二阶导后再绘图或求值)。
+
+*`ty` = > type `f` *
+
+> print text=`ty`
+
+*`df` = > 求导 formula=`f` var=x *
+
+> print text=`df`
+
+*`roots` = > 求解 formula=`f` var=x *
+
+> print text=`roots`
+
+*`_svg` = > 绘图 formula=`f` var=x min=-3 max=3 *
+
+> print text=plot-ok
diff --git a/src/aliases.rs b/src/aliases.rs
index 617568f..4bf3933 100644
--- a/src/aliases.rs
+++ b/src/aliases.rs
@@ -51,6 +51,15 @@ pub fn canonical_param(builtin: &str, param: &str) -> String {
         ("split" | "join", "sep" | "分隔") => "sep".into(),
         ("at", "value" | "值") => "value".into(),
         ("at", "index" | "下标") => "index".into(),
+        (
+            "host_plot" | "host_plot_points" | "host_plot_conic",
+            "grid" | "网格",
+        ) => "grid".into(),
+        ("host_plot" | "host_plot_points" | "host_plot_conic", "path" | "路径") => {
+            "path".into()
+        }
+        ("host_plot", "steps" | "步数") => "steps".into(),
+        ("host_plot", "derivative" | "导数") => "derivative".into(),
         _ => param.to_string(),
     }
 }
diff --git a/src/ast.rs b/src/ast.rs
index 9b533ae..ea8fb50 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -1,6 +1,7 @@
 //! Marqdo AST (Phase I).
 
 use crate::diagnostics::Span;
+use crate::formula::Expr as FormulaExpr;
 
 #[derive(Debug, Clone)]
 pub struct Module {
@@ -24,6 +25,8 @@ pub enum Stmt {
         name: String,
         value: Expr,
         span: Span,
+        /// Inclusive last source line (covers following `$$` fence or table rows).
+        end_line: u32,
     },
     Return {
         value: Expr,
@@ -86,6 +89,8 @@ pub enum Expr {
     },
     Call(CallExpr),
     List(Vec),
+    /// Parsed `$$…$$` formula tree (from assignment RHS).
+    Formula(FormulaExpr),
 }
 
 #[derive(Debug, Clone)]
@@ -156,8 +161,15 @@ fn dump_fun(out: &mut String, fun: &Function, depth: usize) {
 fn dump_stmt(out: &mut String, stmt: &Stmt, depth: usize) {
     let pad = "  ".repeat(depth);
     match stmt {
-        Stmt::Assign { name, value, span } => {
-            out.push_str(&format!("{pad}(assign {name:?} {value:?} @{span})\n"));
+        Stmt::Assign {
+            name,
+            value,
+            span,
+            end_line,
+        } => {
+            out.push_str(&format!(
+                "{pad}(assign {name:?} {value:?} @{span}..{end_line})\n"
+            ));
         }
         Stmt::Return { value, span } => {
             out.push_str(&format!("{pad}(return {value:?} @{span})\n"));
diff --git a/src/builtin.rs b/src/builtin.rs
index 6db2507..e03dddd 100644
--- a/src/builtin.rs
+++ b/src/builtin.rs
@@ -20,6 +20,7 @@ pub fn builtin_str(v: &Value) -> Value {
 pub fn builtin_int(v: &Value) -> Result {
     match v {
         Value::Int(n) => Ok(*n),
+        Value::Num(n) => Ok(*n as i64),
         Value::Bool(true) => Ok(1),
         Value::Bool(false) => Ok(0),
         Value::Text(s) => {
@@ -27,20 +28,22 @@ pub fn builtin_int(v: &Value) -> Result {
             t.parse::()
                 .map_err(|_| format!("cannot convert to int: {s:?}"))
         }
-        _ => Err("int needs int, bool, or text".into()),
+        _ => Err("int needs int, num, bool, or text".into()),
     }
 }
 
-/// `type`: type tag as text (`none` / `bool` / `int` / `text` / `list` / `map`).
+/// `type`: type tag as text (`none` / `bool` / `int` / `num` / `text` / `list` / `map` / `formula`).
 pub fn builtin_type(v: &Value) -> Value {
     Value::Text(
         match v {
             Value::None => "none",
             Value::Bool(_) => "bool",
             Value::Int(_) => "int",
+            Value::Num(_) => "num",
             Value::Text(_) => "text",
             Value::List(_) => "list",
             Value::Map(_) => "map",
+            Value::Formula(_) => "formula",
         }
         .into(),
     )
diff --git a/src/bytecode/compile.rs b/src/bytecode/compile.rs
index 0dd30c2..c1ca5d4 100644
--- a/src/bytecode/compile.rs
+++ b/src/bytecode/compile.rs
@@ -206,7 +206,7 @@ impl<'a> FnCompiler<'a> {
 
     fn compile_stmt(&mut self, stmt: &Stmt) -> Result<()> {
         match stmt {
-            Stmt::Assign { name, value, span } => {
+            Stmt::Assign { name, value, span, .. } => {
                 self.stmt_span = *span;
                 self.compile_expr(value)?;
                 let slot = self.local_slot(name);
@@ -637,6 +637,10 @@ impl<'a> FnCompiler<'a> {
                 }
                 self.emit(Op::BuildList(items.len() as u16));
             }
+            Expr::Formula(e) => {
+                let i = self.add_const(Value::Formula(e.clone()));
+                self.emit(Op::Constant(i));
+            }
         }
         Ok(())
     }
diff --git a/src/bytecode/vm.rs b/src/bytecode/vm.rs
index 03804a8..36e1daa 100644
--- a/src/bytecode/vm.rs
+++ b/src/bytecode/vm.rs
@@ -69,6 +69,10 @@ impl Vm {
         self
     }
 
+    pub fn take_plots(&mut self) -> Vec {
+        std::mem::take(&mut self.host.plots)
+    }
+
     fn emit_line(&mut self, text: &str) {
         if self.capture {
             self.captured_stdout.push_str(text);
@@ -312,7 +316,7 @@ impl Vm {
                         }
                     }
                     let result =
-                        call_host(&self.host, hf, &bound).map_err(|m| self.err_at(span, m))?;
+                        call_host(&mut self.host, hf, &bound).map_err(|m| self.err_at(span, m))?;
                     stack.push(result);
                 }
                 Op::Call(fid, argc) => {
@@ -380,8 +384,15 @@ fn cmp(stack: &mut Vec, pred: impl Fn(std::cmp::Ordering) -> bool) -> Res
     let a = pop(stack)?;
     let ord = match (&a, &b) {
         (Value::Int(x), Value::Int(y)) => x.cmp(y),
+        (Value::Num(x), Value::Num(y)) => x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal),
+        (Value::Int(x), Value::Num(y)) => {
+            (*x as f64).partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal)
+        }
+        (Value::Num(x), Value::Int(y)) => {
+            x.partial_cmp(&(*y as f64)).unwrap_or(std::cmp::Ordering::Equal)
+        }
         (Value::Text(x), Value::Text(y)) => x.cmp(y),
-        _ => return Err("comparison needs two ints or two texts".into()),
+        _ => return Err("comparison needs two ints/nums or two texts".into()),
     };
     stack.push(Value::Bool(pred(ord)));
     Ok(())
diff --git a/src/capture.rs b/src/capture.rs
index 1849b3d..e5867ae 100644
--- a/src/capture.rs
+++ b/src/capture.rs
@@ -1,9 +1,11 @@
 //! Captured program run (for tests and `view`).
 
 use crate::value::Value;
+use crate::host::PlotArtifact;
 
 #[derive(Debug, Clone)]
 pub struct RunCapture {
     pub stdout: String,
     pub value: Value,
+    pub plots: Vec,
 }
diff --git a/src/formula/mod.rs b/src/formula/mod.rs
new file mode 100644
index 0000000..b366847
--- /dev/null
+++ b/src/formula/mod.rs
@@ -0,0 +1,961 @@
+//! High-school formula AST: parse, simplify, diff, eval, solve, plot helpers.
+
+mod plot;
+
+pub use plot::{plot_conic_svg, plot_function_svg, plot_points_svg, PlotStyle};
+
+use std::collections::HashMap;
+use std::fmt;
+
+/// Expression tree for `Value::Formula`.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr {
+    Num(f64),
+    Var(String),
+    UnaryNeg(Box),
+    Bin {
+        op: BinOp,
+        left: Box,
+        right: Box,
+    },
+    Call {
+        name: String,
+        args: Vec,
+    },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Pow,
+}
+
+impl Expr {
+    pub fn num(n: f64) -> Self {
+        Expr::Num(n)
+    }
+
+    pub fn var(name: impl Into) -> Self {
+        Expr::Var(name.into())
+    }
+
+    pub fn as_display(&self) -> String {
+        self.fmt_prec(0)
+    }
+
+    fn fmt_prec(&self, parent_prec: u8) -> String {
+        match self {
+            Expr::Num(n) => format_num(*n),
+            Expr::Var(v) => v.clone(),
+            Expr::UnaryNeg(e) => {
+                let inner = e.fmt_prec(3);
+                let s = format!("-{inner}");
+                if parent_prec > 2 {
+                    format!("({s})")
+                } else {
+                    s
+                }
+            }
+            Expr::Bin { op, left, right } => {
+                let prec = op.prec();
+                let ls = left.fmt_prec(prec);
+                let rs = right.fmt_prec(if matches!(op, BinOp::Sub | BinOp::Div) {
+                    prec + 1
+                } else if matches!(op, BinOp::Pow) {
+                    prec
+                } else {
+                    prec
+                });
+                let s = format!("{ls}{}{rs}", op.sym());
+                if prec < parent_prec {
+                    format!("({s})")
+                } else {
+                    s
+                }
+            }
+            Expr::Call { name, args } => {
+                let joined: Vec = args.iter().map(|a| a.as_display()).collect();
+                format!("{name}({})", joined.join(", "))
+            }
+        }
+    }
+}
+
+impl fmt::Display for Expr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_display())
+    }
+}
+
+impl BinOp {
+    fn prec(self) -> u8 {
+        match self {
+            BinOp::Add | BinOp::Sub => 1,
+            BinOp::Mul | BinOp::Div => 2,
+            BinOp::Pow => 3,
+        }
+    }
+
+    fn sym(self) -> &'static str {
+        match self {
+            BinOp::Add => " + ",
+            BinOp::Sub => " - ",
+            BinOp::Mul => "*",
+            BinOp::Div => "/",
+            BinOp::Pow => "^",
+        }
+    }
+}
+
+pub fn format_num(n: f64) -> String {
+    if n.is_nan() {
+        return "nan".into();
+    }
+    if n.is_infinite() {
+        return if n.is_sign_positive() {
+            "inf".into()
+        } else {
+            "-inf".into()
+        };
+    }
+    if n.fract() == 0.0 && n.abs() < 1e15 {
+        return format!("{}", n as i64);
+    }
+    let s = format!("{n:.10}");
+    let s = s.trim_end_matches('0').trim_end_matches('.');
+    if s.is_empty() || s == "-" {
+        "0".into()
+    } else {
+        s.to_string()
+    }
+}
+
+/// Parse ASCII formula text (`sin(x) + x^2`, optional simple `y = …` left strip).
+pub fn parse(input: &str) -> Result {
+    let t = input.trim();
+    if t.is_empty() {
+        return Err("empty formula".into());
+    }
+    let body = if let Some((lhs, rhs)) = t.split_once('=') {
+        let lhs = lhs.trim();
+        if lhs.chars().all(|c| c.is_ascii_alphabetic() || c == '_') && !rhs.trim().is_empty() {
+            rhs.trim()
+        } else {
+            t
+        }
+    } else {
+        t
+    };
+    let mut p = Parser {
+        src: body.chars().collect(),
+        i: 0,
+    };
+    let e = p.parse_expr()?;
+    p.skip_ws();
+    if p.i < p.src.len() {
+        return Err(format!(
+            "unexpected trailing input near `{}`",
+            p.src[p.i..].iter().collect::()
+        ));
+    }
+    Ok(e)
+}
+
+struct Parser {
+    src: Vec,
+    i: usize,
+}
+
+impl Parser {
+    fn skip_ws(&mut self) {
+        while self.i < self.src.len() && self.src[self.i].is_whitespace() {
+            self.i += 1;
+        }
+    }
+
+    fn peek(&mut self) -> Option {
+        self.skip_ws();
+        self.src.get(self.i).copied()
+    }
+
+    fn bump(&mut self) -> Option {
+        self.skip_ws();
+        let c = self.src.get(self.i).copied()?;
+        self.i += 1;
+        Some(c)
+    }
+
+    fn parse_expr(&mut self) -> Result {
+        self.parse_add()
+    }
+
+    fn parse_add(&mut self) -> Result {
+        let mut left = self.parse_mul()?;
+        loop {
+            match self.peek() {
+                Some('+') => {
+                    self.bump();
+                    let right = self.parse_mul()?;
+                    left = Expr::Bin {
+                        op: BinOp::Add,
+                        left: Box::new(left),
+                        right: Box::new(right),
+                    };
+                }
+                Some('-') => {
+                    self.bump();
+                    let right = self.parse_mul()?;
+                    left = Expr::Bin {
+                        op: BinOp::Sub,
+                        left: Box::new(left),
+                        right: Box::new(right),
+                    };
+                }
+                _ => break,
+            }
+        }
+        Ok(left)
+    }
+
+    fn parse_mul(&mut self) -> Result {
+        let mut left = self.parse_pow()?;
+        loop {
+            match self.peek() {
+                Some('*') => {
+                    self.bump();
+                    let right = self.parse_pow()?;
+                    left = Expr::Bin {
+                        op: BinOp::Mul,
+                        left: Box::new(left),
+                        right: Box::new(right),
+                    };
+                }
+                Some('/') => {
+                    self.bump();
+                    let right = self.parse_pow()?;
+                    left = Expr::Bin {
+                        op: BinOp::Div,
+                        left: Box::new(left),
+                        right: Box::new(right),
+                    };
+                }
+                _ => break,
+            }
+        }
+        Ok(left)
+    }
+
+    fn parse_pow(&mut self) -> Result {
+        let left = self.parse_unary()?;
+        if self.peek() == Some('^') {
+            self.bump();
+            let right = self.parse_pow()?; // right-assoc
+            Ok(Expr::Bin {
+                op: BinOp::Pow,
+                left: Box::new(left),
+                right: Box::new(right),
+            })
+        } else {
+            Ok(left)
+        }
+    }
+
+    fn parse_unary(&mut self) -> Result {
+        match self.peek() {
+            Some('+') => {
+                self.bump();
+                self.parse_unary()
+            }
+            Some('-') => {
+                self.bump();
+                Ok(Expr::UnaryNeg(Box::new(self.parse_unary()?)))
+            }
+            _ => self.parse_primary(),
+        }
+    }
+
+    fn parse_primary(&mut self) -> Result {
+        match self.peek() {
+            Some('(') => {
+                self.bump();
+                let e = self.parse_expr()?;
+                if self.bump() != Some(')') {
+                    return Err("expected `)`".into());
+                }
+                Ok(e)
+            }
+            Some(c) if c.is_ascii_digit() || c == '.' => self.parse_number(),
+            Some(c) if c.is_ascii_alphabetic() || c == '_' => {
+                let name = self.parse_ident()?;
+                if self.peek() == Some('(') {
+                    self.bump();
+                    let mut args = Vec::new();
+                    if self.peek() != Some(')') {
+                        loop {
+                            args.push(self.parse_expr()?);
+                            match self.peek() {
+                                Some(',') => {
+                                    self.bump();
+                                }
+                                Some(')') => break,
+                                _ => return Err("expected `,` or `)` in call".into()),
+                            }
+                        }
+                    }
+                    if self.bump() != Some(')') {
+                        return Err("expected `)` after call args".into());
+                    }
+                    Ok(Expr::Call { name, args })
+                } else {
+                    Ok(Expr::Var(name))
+                }
+            }
+            Some(c) => Err(format!("unexpected `{c}` in formula")),
+            None => Err("unexpected end of formula".into()),
+        }
+    }
+
+    fn parse_number(&mut self) -> Result {
+        self.skip_ws();
+        let start = self.i;
+        while self.i < self.src.len()
+            && (self.src[self.i].is_ascii_digit() || self.src[self.i] == '.')
+        {
+            self.i += 1;
+        }
+        let s: String = self.src[start..self.i].iter().collect();
+        let n: f64 = s
+            .parse()
+            .map_err(|_| format!("invalid number `{s}`"))?;
+        Ok(Expr::Num(n))
+    }
+
+    fn parse_ident(&mut self) -> Result {
+        self.skip_ws();
+        let start = self.i;
+        while self.i < self.src.len() {
+            let c = self.src[self.i];
+            if c.is_ascii_alphanumeric() || c == '_' {
+                self.i += 1;
+            } else {
+                break;
+            }
+        }
+        if start == self.i {
+            return Err("expected identifier".into());
+        }
+        Ok(self.src[start..self.i].iter().collect())
+    }
+}
+
+/// Constant-fold + light algebraic cleanup.
+pub fn simplify(e: &Expr) -> Expr {
+    match e {
+        Expr::Num(n) => Expr::Num(*n),
+        Expr::Var(v) => Expr::Var(v.clone()),
+        Expr::UnaryNeg(inner) => {
+            let i = simplify(inner);
+            match i {
+                Expr::Num(n) => Expr::Num(-n),
+                Expr::UnaryNeg(x) => *x,
+                other => Expr::UnaryNeg(Box::new(other)),
+            }
+        }
+        Expr::Bin { op, left, right } => {
+            let l = simplify(left);
+            let r = simplify(right);
+            fold_bin(*op, l, r)
+        }
+        Expr::Call { name, args } => {
+            let args: Vec = args.iter().map(simplify).collect();
+            if args.len() == 1 {
+                if let Expr::Num(n) = &args[0] {
+                    if let Some(v) = eval_call_f64(name, &[*n]) {
+                        return Expr::Num(v);
+                    }
+                }
+            }
+            Expr::Call {
+                name: name.clone(),
+                args,
+            }
+        }
+    }
+}
+
+fn fold_bin(op: BinOp, l: Expr, r: Expr) -> Expr {
+    match (op, &l, &r) {
+        (BinOp::Add, Expr::Num(a), Expr::Num(b)) => Expr::Num(a + b),
+        (BinOp::Sub, Expr::Num(a), Expr::Num(b)) => Expr::Num(a - b),
+        (BinOp::Mul, Expr::Num(a), Expr::Num(b)) => Expr::Num(a * b),
+        (BinOp::Div, Expr::Num(a), Expr::Num(b)) if *b != 0.0 => Expr::Num(a / b),
+        (BinOp::Pow, Expr::Num(a), Expr::Num(b)) => Expr::Num(a.powf(*b)),
+        (BinOp::Add, _, Expr::Num(0.0)) => l,
+        (BinOp::Add, Expr::Num(0.0), _) => r,
+        (BinOp::Sub, _, Expr::Num(0.0)) => l,
+        (BinOp::Mul, _, Expr::Num(1.0)) => l,
+        (BinOp::Mul, Expr::Num(1.0), _) => r,
+        (BinOp::Mul, _, Expr::Num(0.0)) | (BinOp::Mul, Expr::Num(0.0), _) => Expr::Num(0.0),
+        (BinOp::Pow, _, Expr::Num(1.0)) => l,
+        (BinOp::Pow, _, Expr::Num(0.0)) => Expr::Num(1.0),
+        (BinOp::Div, _, Expr::Num(1.0)) => l,
+        _ => Expr::Bin {
+            op,
+            left: Box::new(l),
+            right: Box::new(r),
+        },
+    }
+}
+
+/// Lightweight expand: distribute multiplication over addition one level.
+pub fn expand(e: &Expr) -> Expr {
+    let e = simplify(e);
+    match e {
+        Expr::Bin {
+            op: BinOp::Mul,
+            left,
+            right,
+        } => {
+            let l = expand(&left);
+            let r = expand(&right);
+            match (l, r) {
+                (
+                    Expr::Bin {
+                        op: BinOp::Add,
+                        left: a,
+                        right: b,
+                    },
+                    r,
+                ) => simplify(&Expr::Bin {
+                    op: BinOp::Add,
+                    left: Box::new(Expr::Bin {
+                        op: BinOp::Mul,
+                        left: a,
+                        right: Box::new(r.clone()),
+                    }),
+                    right: Box::new(Expr::Bin {
+                        op: BinOp::Mul,
+                        left: b,
+                        right: Box::new(r),
+                    }),
+                }),
+                (
+                    l,
+                    Expr::Bin {
+                        op: BinOp::Add,
+                        left: a,
+                        right: b,
+                    },
+                ) => simplify(&Expr::Bin {
+                    op: BinOp::Add,
+                    left: Box::new(Expr::Bin {
+                        op: BinOp::Mul,
+                        left: Box::new(l.clone()),
+                        right: a,
+                    }),
+                    right: Box::new(Expr::Bin {
+                        op: BinOp::Mul,
+                        left: Box::new(l),
+                        right: b,
+                    }),
+                }),
+                (l, r) => simplify(&Expr::Bin {
+                    op: BinOp::Mul,
+                    left: Box::new(l),
+                    right: Box::new(r),
+                }),
+            }
+        }
+        Expr::Bin { op, left, right } => simplify(&Expr::Bin {
+            op,
+            left: Box::new(expand(&left)),
+            right: Box::new(expand(&right)),
+        }),
+        Expr::UnaryNeg(x) => simplify(&Expr::UnaryNeg(Box::new(expand(&x)))),
+        Expr::Call { name, args } => Expr::Call {
+            name,
+            args: args.iter().map(expand).collect(),
+        },
+        other => other,
+    }
+}
+
+pub fn diff(e: &Expr, var: &str) -> Expr {
+    simplify(&diff_raw(e, var))
+}
+
+fn diff_raw(e: &Expr, var: &str) -> Expr {
+    match e {
+        Expr::Num(_) => Expr::Num(0.0),
+        Expr::Var(v) => {
+            if v == var {
+                Expr::Num(1.0)
+            } else {
+                Expr::Num(0.0)
+            }
+        }
+        Expr::UnaryNeg(x) => Expr::UnaryNeg(Box::new(diff_raw(x, var))),
+        Expr::Bin {
+            op: BinOp::Add,
+            left,
+            right,
+        } => Expr::Bin {
+            op: BinOp::Add,
+            left: Box::new(diff_raw(left, var)),
+            right: Box::new(diff_raw(right, var)),
+        },
+        Expr::Bin {
+            op: BinOp::Sub,
+            left,
+            right,
+        } => Expr::Bin {
+            op: BinOp::Sub,
+            left: Box::new(diff_raw(left, var)),
+            right: Box::new(diff_raw(right, var)),
+        },
+        Expr::Bin {
+            op: BinOp::Mul,
+            left,
+            right,
+        } => {
+            // product rule
+            Expr::Bin {
+                op: BinOp::Add,
+                left: Box::new(Expr::Bin {
+                    op: BinOp::Mul,
+                    left: Box::new(diff_raw(left, var)),
+                    right: right.clone(),
+                }),
+                right: Box::new(Expr::Bin {
+                    op: BinOp::Mul,
+                    left: left.clone(),
+                    right: Box::new(diff_raw(right, var)),
+                }),
+            }
+        }
+        Expr::Bin {
+            op: BinOp::Div,
+            left,
+            right,
+        } => {
+            // (u'v - uv') / v^2
+            let num = Expr::Bin {
+                op: BinOp::Sub,
+                left: Box::new(Expr::Bin {
+                    op: BinOp::Mul,
+                    left: Box::new(diff_raw(left, var)),
+                    right: right.clone(),
+                }),
+                right: Box::new(Expr::Bin {
+                    op: BinOp::Mul,
+                    left: left.clone(),
+                    right: Box::new(diff_raw(right, var)),
+                }),
+            };
+            Expr::Bin {
+                op: BinOp::Div,
+                left: Box::new(num),
+                right: Box::new(Expr::Bin {
+                    op: BinOp::Pow,
+                    left: right.clone(),
+                    right: Box::new(Expr::Num(2.0)),
+                }),
+            }
+        }
+        Expr::Bin {
+            op: BinOp::Pow,
+            left,
+            right,
+        } => {
+            // d/dx [u^n] when n constant: n*u^(n-1)*u'
+            if let Expr::Num(n) = right.as_ref() {
+                Expr::Bin {
+                    op: BinOp::Mul,
+                    left: Box::new(Expr::Bin {
+                        op: BinOp::Mul,
+                        left: Box::new(Expr::Num(*n)),
+                        right: Box::new(Expr::Bin {
+                            op: BinOp::Pow,
+                            left: left.clone(),
+                            right: Box::new(Expr::Num(n - 1.0)),
+                        }),
+                    }),
+                    right: Box::new(diff_raw(left, var)),
+                }
+            } else {
+                // a^u → a^u * ln(a) * u' when a constant
+                if let Expr::Num(a) = left.as_ref() {
+                    Expr::Bin {
+                        op: BinOp::Mul,
+                        left: Box::new(Expr::Bin {
+                            op: BinOp::Mul,
+                            left: Box::new(e.clone()),
+                            right: Box::new(Expr::Call {
+                                name: "ln".into(),
+                                args: vec![Expr::Num(*a)],
+                            }),
+                        }),
+                        right: Box::new(diff_raw(right, var)),
+                    }
+                } else {
+                    // fallback: treat as exp(v*ln(u))
+                    Expr::Num(0.0)
+                }
+            }
+        }
+        Expr::Call { name, args } => {
+            if args.len() != 1 {
+                return Expr::Num(0.0);
+            }
+            let u = &args[0];
+            let du = diff_raw(u, var);
+            let chain = |outer: Expr| {
+                Expr::Bin {
+                    op: BinOp::Mul,
+                    left: Box::new(outer),
+                    right: Box::new(du.clone()),
+                }
+            };
+            match name.as_str() {
+                "sin" => chain(Expr::Call {
+                    name: "cos".into(),
+                    args: vec![u.clone()],
+                }),
+                "cos" => chain(Expr::UnaryNeg(Box::new(Expr::Call {
+                    name: "sin".into(),
+                    args: vec![u.clone()],
+                }))),
+                "tan" => chain(Expr::Bin {
+                    op: BinOp::Pow,
+                    left: Box::new(Expr::Call {
+                        name: "cos".into(),
+                        args: vec![u.clone()],
+                    }),
+                    right: Box::new(Expr::Num(-2.0)),
+                }),
+                "sqrt" => chain(Expr::Bin {
+                    op: BinOp::Div,
+                    left: Box::new(Expr::Num(1.0)),
+                    right: Box::new(Expr::Bin {
+                        op: BinOp::Mul,
+                        left: Box::new(Expr::Num(2.0)),
+                        right: Box::new(Expr::Call {
+                            name: "sqrt".into(),
+                            args: vec![u.clone()],
+                        }),
+                    }),
+                }),
+                "ln" | "log" => chain(Expr::Bin {
+                    op: BinOp::Div,
+                    left: Box::new(Expr::Num(1.0)),
+                    right: Box::new(u.clone()),
+                }),
+                "exp" => chain(Expr::Call {
+                    name: "exp".into(),
+                    args: vec![u.clone()],
+                }),
+                "abs" => {
+                    // sign(u)*u' — use u/abs(u) when u≠0
+                    chain(Expr::Bin {
+                        op: BinOp::Div,
+                        left: Box::new(u.clone()),
+                        right: Box::new(Expr::Call {
+                            name: "abs".into(),
+                            args: vec![u.clone()],
+                        }),
+                    })
+                }
+                _ => Expr::Num(0.0),
+            }
+        }
+    }
+}
+
+pub fn subs(e: &Expr, var: &str, value: &Expr) -> Expr {
+    simplify(&subs_raw(e, var, value))
+}
+
+fn subs_raw(e: &Expr, var: &str, value: &Expr) -> Expr {
+    match e {
+        Expr::Num(n) => Expr::Num(*n),
+        Expr::Var(v) => {
+            if v == var {
+                value.clone()
+            } else {
+                Expr::Var(v.clone())
+            }
+        }
+        Expr::UnaryNeg(x) => Expr::UnaryNeg(Box::new(subs_raw(x, var, value))),
+        Expr::Bin { op, left, right } => Expr::Bin {
+            op: *op,
+            left: Box::new(subs_raw(left, var, value)),
+            right: Box::new(subs_raw(right, var, value)),
+        },
+        Expr::Call { name, args } => Expr::Call {
+            name: name.clone(),
+            args: args.iter().map(|a| subs_raw(a, var, value)).collect(),
+        },
+    }
+}
+
+pub fn eval_f64(e: &Expr, env: &HashMap) -> Result {
+    match e {
+        Expr::Num(n) => Ok(*n),
+        Expr::Var(v) => env
+            .get(v)
+            .copied()
+            .ok_or_else(|| format!("unbound variable `{v}`")),
+        Expr::UnaryNeg(x) => Ok(-eval_f64(x, env)?),
+        Expr::Bin { op, left, right } => {
+            let a = eval_f64(left, env)?;
+            let b = eval_f64(right, env)?;
+            Ok(match op {
+                BinOp::Add => a + b,
+                BinOp::Sub => a - b,
+                BinOp::Mul => a * b,
+                BinOp::Div => {
+                    if b == 0.0 {
+                        return Err("division by zero".into());
+                    }
+                    a / b
+                }
+                BinOp::Pow => a.powf(b),
+            })
+        }
+        Expr::Call { name, args } => {
+            let mut xs = Vec::with_capacity(args.len());
+            for a in args {
+                xs.push(eval_f64(a, env)?);
+            }
+            eval_call_f64(name, &xs).ok_or_else(|| format!("unknown or arity-mismatch function `{name}`"))
+        }
+    }
+}
+
+fn eval_call_f64(name: &str, args: &[f64]) -> Option {
+    match (name, args) {
+        ("sin", [x]) => Some(x.sin()),
+        ("cos", [x]) => Some(x.cos()),
+        ("tan", [x]) => Some(x.tan()),
+        ("asin", [x]) => Some(x.asin()),
+        ("acos", [x]) => Some(x.acos()),
+        ("atan", [x]) => Some(x.atan()),
+        ("sqrt", [x]) => Some(x.sqrt()),
+        ("abs", [x]) => Some(x.abs()),
+        ("ln" | "log", [x]) => Some(x.ln()),
+        ("exp", [x]) => Some(x.exp()),
+        ("floor", [x]) => Some(x.floor()),
+        ("ceil", [x]) => Some(x.ceil()),
+        ("pow", [a, b]) => Some(a.powf(*b)),
+        ("min", [a, b]) => Some(a.min(*b)),
+        ("max", [a, b]) => Some(a.max(*b)),
+        _ => None,
+    }
+}
+
+/// Solve `e = 0` for `var`. Quadratic/linear closed form; else numeric scan.
+pub fn solve(e: &Expr, var: &str, xmin: f64, xmax: f64) -> Result, String> {
+    let e = expand(&simplify(e));
+    if let Some(roots) = try_polynomial_solve(&e, var) {
+        return Ok(roots);
+    }
+    numeric_roots(&e, var, xmin, xmax)
+}
+
+fn try_polynomial_solve(e: &Expr, var: &str) -> Option> {
+    let (a, b, c) = poly_coeffs_quadratic(e, var)?;
+    if a.abs() < 1e-12 {
+        if b.abs() < 1e-12 {
+            return if c.abs() < 1e-12 {
+                None // identity
+            } else {
+                Some(vec![])
+            };
+        }
+        return Some(vec![-c / b]);
+    }
+    let disc = b * b - 4.0 * a * c;
+    if disc < -1e-12 {
+        return Some(vec![]);
+    }
+    if disc.abs() <= 1e-12 {
+        return Some(vec![-b / (2.0 * a)]);
+    }
+    let s = disc.sqrt();
+    let mut roots = vec![(-b - s) / (2.0 * a), (-b + s) / (2.0 * a)];
+    roots.sort_by(|x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal));
+    Some(roots)
+}
+
+/// Collect ax^2+bx+c if expression is a polynomial of degree ≤ 2 in `var`.
+fn poly_coeffs_quadratic(e: &Expr, var: &str) -> Option<(f64, f64, f64)> {
+    let mut a = 0.0;
+    let mut b = 0.0;
+    let mut c = 0.0;
+    if !accum_poly(e, var, 1.0, &mut a, &mut b, &mut c) {
+        return None;
+    }
+    Some((a, b, c))
+}
+
+fn accum_poly(e: &Expr, var: &str, scale: f64, a: &mut f64, b: &mut f64, c: &mut f64) -> bool {
+    match e {
+        Expr::Num(n) => {
+            *c += scale * n;
+            true
+        }
+        Expr::Var(v) if v == var => {
+            *b += scale;
+            true
+        }
+        Expr::Var(_) => false,
+        Expr::UnaryNeg(x) => accum_poly(x, var, -scale, a, b, c),
+        Expr::Bin {
+            op: BinOp::Add,
+            left,
+            right,
+        } => accum_poly(left, var, scale, a, b, c) && accum_poly(right, var, scale, a, b, c),
+        Expr::Bin {
+            op: BinOp::Sub,
+            left,
+            right,
+        } => accum_poly(left, var, scale, a, b, c) && accum_poly(right, var, -scale, a, b, c),
+        Expr::Bin {
+            op: BinOp::Mul,
+            left,
+            right,
+        } => match (left.as_ref(), right.as_ref()) {
+            (Expr::Num(n), r) => accum_poly(r, var, scale * n, a, b, c),
+            (l, Expr::Num(n)) => accum_poly(l, var, scale * n, a, b, c),
+            (Expr::Var(v), Expr::Var(w)) if v == var && w == var => {
+                *a += scale;
+                true
+            }
+            (
+                Expr::Bin {
+                    op: BinOp::Pow,
+                    left: base,
+                    right: exp,
+                },
+                other,
+            )
+            | (
+                other,
+                Expr::Bin {
+                    op: BinOp::Pow,
+                    left: base,
+                    right: exp,
+                },
+            ) => {
+                if let (Expr::Var(v), Expr::Num(2.0)) = (base.as_ref(), exp.as_ref()) {
+                    if v == var {
+                        if let Expr::Num(n) = other {
+                            *a += scale * n;
+                            return true;
+                        }
+                    }
+                }
+                false
+            }
+            _ => false,
+        },
+        Expr::Bin {
+            op: BinOp::Pow,
+            left,
+            right,
+        } => match (left.as_ref(), right.as_ref()) {
+            (Expr::Var(v), Expr::Num(2.0)) if v == var => {
+                *a += scale;
+                true
+            }
+            (Expr::Var(v), Expr::Num(1.0)) if v == var => {
+                *b += scale;
+                true
+            }
+            (Expr::Var(v), Expr::Num(0.0)) if v == var => {
+                *c += scale;
+                true
+            }
+            _ => false,
+        },
+        _ => false,
+    }
+}
+
+fn numeric_roots(e: &Expr, var: &str, xmin: f64, xmax: f64) -> Result, String> {
+    const STEPS: usize = 200;
+    let mut roots = Vec::new();
+    let mut env = HashMap::new();
+    let dx = (xmax - xmin) / STEPS as f64;
+    let mut x0 = xmin;
+    env.insert(var.to_string(), x0);
+    let mut y0 = eval_f64(e, &env)?;
+    for i in 1..=STEPS {
+        let x1 = xmin + dx * i as f64;
+        env.insert(var.to_string(), x1);
+        let y1 = eval_f64(e, &env)?;
+        if y0 == 0.0 {
+            push_unique(&mut roots, x0);
+        } else if y0.signum() != y1.signum() && y1 != 0.0 {
+            // bisection
+            let mut lo = x0;
+            let mut hi = x1;
+            let mut flo = y0;
+            for _ in 0..40 {
+                let mid = 0.5 * (lo + hi);
+                env.insert(var.to_string(), mid);
+                let fm = eval_f64(e, &env)?;
+                if fm == 0.0 || (hi - lo).abs() < 1e-10 {
+                    push_unique(&mut roots, mid);
+                    break;
+                }
+                if flo.signum() == fm.signum() {
+                    lo = mid;
+                    flo = fm;
+                } else {
+                    hi = mid;
+                }
+            }
+        }
+        if i == STEPS && y1 == 0.0 {
+            push_unique(&mut roots, x1);
+        }
+        x0 = x1;
+        y0 = y1;
+    }
+    Ok(roots)
+}
+
+fn push_unique(xs: &mut Vec, x: f64) {
+    if xs.iter().any(|y| (y - x).abs() < 1e-6) {
+        return;
+    }
+    xs.push(x);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_and_diff_quadratic() {
+        let e = parse("x^2 - 2").unwrap();
+        let d = diff(&e, "x");
+        assert_eq!(d.as_display(), "2*x");
+        let roots = solve(&e, "x", -10.0, 10.0).unwrap();
+        assert_eq!(roots.len(), 2);
+        assert!((roots[0] + 2f64.sqrt()).abs() < 1e-6);
+        assert!((roots[1] - 2f64.sqrt()).abs() < 1e-6);
+    }
+
+    #[test]
+    fn eval_sin() {
+        let e = parse("sin(x)").unwrap();
+        let mut env = HashMap::new();
+        env.insert("x".into(), 0.0);
+        assert!((eval_f64(&e, &env).unwrap()).abs() < 1e-12);
+    }
+}
diff --git a/src/formula/plot.rs b/src/formula/plot.rs
new file mode 100644
index 0000000..c4d8595
--- /dev/null
+++ b/src/formula/plot.rs
@@ -0,0 +1,432 @@
+//! SVG plot helpers for high-school graphs.
+
+use std::collections::HashMap;
+
+use super::{eval_f64, Expr};
+
+const MAX_STEPS: usize = 2000;
+const DEFAULT_STEPS: usize = 200;
+const SVG_W: f64 = 520.0;
+const SVG_H: f64 = 360.0;
+const PAD: f64 = 36.0;
+
+#[derive(Debug, Clone, Copy)]
+pub struct PlotStyle {
+    pub grid: bool,
+}
+
+impl Default for PlotStyle {
+    fn default() -> Self {
+        Self { grid: true }
+    }
+}
+
+pub fn plot_function_svg(
+    expr: &Expr,
+    var: &str,
+    xmin: f64,
+    xmax: f64,
+    steps: usize,
+    style: PlotStyle,
+) -> Result {
+    if !(xmin.is_finite() && xmax.is_finite()) || xmax <= xmin {
+        return Err("plot needs finite min < max".into());
+    }
+    let steps = steps.clamp(2, MAX_STEPS);
+    let mut env = HashMap::new();
+    let mut pts: Vec<(f64, f64)> = Vec::with_capacity(steps + 1);
+    let mut ymin = f64::INFINITY;
+    let mut ymax = f64::NEG_INFINITY;
+    for i in 0..=steps {
+        let x = xmin + (xmax - xmin) * (i as f64) / (steps as f64);
+        env.insert(var.to_string(), x);
+        match eval_f64(expr, &env) {
+            Ok(y) if y.is_finite() => {
+                ymin = ymin.min(y);
+                ymax = ymax.max(y);
+                pts.push((x, y));
+            }
+            _ => {}
+        }
+    }
+    if pts.is_empty() {
+        return Err("plot produced no finite points".into());
+    }
+    if (ymax - ymin).abs() < 1e-12 {
+        ymin -= 1.0;
+        ymax += 1.0;
+    }
+    let pad_y = 0.05 * (ymax - ymin);
+    ymin -= pad_y;
+    ymax += pad_y;
+
+    let mut path = String::new();
+    for (i, (x, y)) in pts.iter().enumerate() {
+        let (sx, sy) = map_xy(*x, *y, xmin, xmax, ymin, ymax);
+        if i == 0 {
+            path.push_str(&format!("M {sx:.2} {sy:.2}"));
+        } else {
+            path.push_str(&format!(" L {sx:.2} {sy:.2}"));
+        }
+    }
+
+    let frame = draw_frame(xmin, xmax, ymin, ymax, style);
+    Ok(svg_wrap(
+        &format!(r#"{frame}"#),
+        "function plot",
+    ))
+}
+
+pub fn plot_points_svg(xs: &[f64], ys: &[f64], style: PlotStyle) -> Result {
+    if xs.len() != ys.len() {
+        return Err("plot_points: xs and ys length mismatch".into());
+    }
+    if xs.is_empty() {
+        return Err("plot_points: empty series".into());
+    }
+    let xmin = xs.iter().cloned().fold(f64::INFINITY, f64::min);
+    let xmax = xs.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
+    let ymin = ys.iter().cloned().fold(f64::INFINITY, f64::min);
+    let ymax = ys.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
+    let (xmin, xmax) = pad_range(xmin, xmax);
+    let (ymin, ymax) = pad_range(ymin, ymax);
+    let mut dots = String::new();
+    for (x, y) in xs.iter().zip(ys.iter()) {
+        if !x.is_finite() || !y.is_finite() {
+            continue;
+        }
+        let (sx, sy) = map_xy(*x, *y, xmin, xmax, ymin, ymax);
+        dots.push_str(&format!(
+            r#""#
+        ));
+    }
+    let frame = draw_frame(xmin, xmax, ymin, ymax, style);
+    Ok(svg_wrap(&format!("{frame}{dots}"), "points plot"))
+}
+
+/// Standard conics via parametric sampling.
+/// kind: circle | ellipse | hyperbola | parabola
+pub fn plot_conic_svg(
+    kind: &str,
+    a: f64,
+    b: f64,
+    h: f64,
+    k: f64,
+    style: PlotStyle,
+) -> Result {
+    let steps = DEFAULT_STEPS;
+    let mut pts: Vec<(f64, f64)> = Vec::new();
+    match kind {
+        "circle" => {
+            let r = if a > 0.0 { a } else { b };
+            if r <= 0.0 {
+                return Err("circle needs positive radius (a)".into());
+            }
+            for i in 0..=steps {
+                let t = std::f64::consts::TAU * (i as f64) / (steps as f64);
+                pts.push((h + r * t.cos(), k + r * t.sin()));
+            }
+        }
+        "ellipse" => {
+            if a <= 0.0 || b <= 0.0 {
+                return Err("ellipse needs a>0, b>0".into());
+            }
+            for i in 0..=steps {
+                let t = std::f64::consts::TAU * (i as f64) / (steps as f64);
+                pts.push((h + a * t.cos(), k + b * t.sin()));
+            }
+        }
+        "hyperbola" => {
+            if a <= 0.0 || b <= 0.0 {
+                return Err("hyperbola needs a>0, b>0".into());
+            }
+            for branch in [-1.0_f64, 1.0] {
+                for i in 0..=steps {
+                    let t = -2.0 + 4.0 * (i as f64) / (steps as f64);
+                    pts.push((h + branch * a * t.cosh(), k + b * t.sinh()));
+                }
+            }
+            let mid = pts.len() / 2;
+            let (left, right) = pts.split_at(mid);
+            let xmin = pts.iter().map(|p| p.0).fold(f64::INFINITY, f64::min);
+            let xmax = pts.iter().map(|p| p.0).fold(f64::NEG_INFINITY, f64::max);
+            let ymin = pts.iter().map(|p| p.1).fold(f64::INFINITY, f64::min);
+            let ymax = pts.iter().map(|p| p.1).fold(f64::NEG_INFINITY, f64::max);
+            let (xmin, xmax) = pad_range(xmin, xmax);
+            let (ymin, ymax) = pad_range(ymin, ymax);
+            let p1 = polyline_path(left, xmin, xmax, ymin, ymax);
+            let p2 = polyline_path(right, xmin, xmax, ymin, ymax);
+            let frame = draw_frame(xmin, xmax, ymin, ymax, style);
+            return Ok(svg_wrap(
+                &format!(
+                    r#"{frame}"#
+                ),
+                "hyperbola",
+            ));
+        }
+        "parabola" => {
+            let scale = if a.abs() > 1e-12 { a } else { 1.0 };
+            for i in 0..=steps {
+                let t = -3.0 + 6.0 * (i as f64) / (steps as f64);
+                let x = h + t;
+                let y = k + (t * t) / (4.0 * scale.abs()) * scale.signum();
+                pts.push((x, y));
+            }
+        }
+        other => return Err(format!("unknown conic kind `{other}`")),
+    }
+
+    let xmin = pts.iter().map(|p| p.0).fold(f64::INFINITY, f64::min);
+    let xmax = pts.iter().map(|p| p.0).fold(f64::NEG_INFINITY, f64::max);
+    let ymin = pts.iter().map(|p| p.1).fold(f64::INFINITY, f64::min);
+    let ymax = pts.iter().map(|p| p.1).fold(f64::NEG_INFINITY, f64::max);
+    let (xmin, xmax) = pad_range(xmin, xmax);
+    let (ymin, ymax) = pad_range(ymin, ymax);
+    let path = polyline_path(&pts, xmin, xmax, ymin, ymax);
+    let frame = draw_frame(xmin, xmax, ymin, ymax, style);
+    Ok(svg_wrap(
+        &format!(r#"{frame}"#),
+        kind,
+    ))
+}
+
+fn pad_range(lo: f64, hi: f64) -> (f64, f64) {
+    if (hi - lo).abs() < 1e-12 {
+        (lo - 1.0, hi + 1.0)
+    } else {
+        let pad = 0.05 * (hi - lo);
+        (lo - pad, hi + pad)
+    }
+}
+
+fn polyline_path(pts: &[(f64, f64)], xmin: f64, xmax: f64, ymin: f64, ymax: f64) -> String {
+    let mut path = String::new();
+    for (i, (x, y)) in pts.iter().enumerate() {
+        let (sx, sy) = map_xy(*x, *y, xmin, xmax, ymin, ymax);
+        if i == 0 {
+            path.push_str(&format!("M {sx:.2} {sy:.2}"));
+        } else {
+            path.push_str(&format!(" L {sx:.2} {sy:.2}"));
+        }
+    }
+    path
+}
+
+fn map_xy(x: f64, y: f64, xmin: f64, xmax: f64, ymin: f64, ymax: f64) -> (f64, f64) {
+    let w = SVG_W - 2.0 * PAD;
+    let h = SVG_H - 2.0 * PAD;
+    let sx = PAD + (x - xmin) / (xmax - xmin) * w;
+    let sy = PAD + (ymax - y) / (ymax - ymin) * h;
+    (sx, sy)
+}
+
+fn nice_step(span: f64, target: usize) -> f64 {
+    let target = target.max(2) as f64;
+    let raw = (span / target).abs().max(1e-12);
+    let exp = raw.log10().floor();
+    let mag = 10f64.powf(exp);
+    let norm = raw / mag;
+    let nice = if norm <= 1.5 {
+        1.0
+    } else if norm <= 3.0 {
+        2.0
+    } else if norm <= 7.0 {
+        5.0
+    } else {
+        10.0
+    };
+    nice * mag
+}
+
+fn tick_values(lo: f64, hi: f64, step: f64) -> Vec {
+    if step <= 0.0 || !step.is_finite() {
+        return Vec::new();
+    }
+    let start = (lo / step).ceil() * step;
+    let mut out = Vec::new();
+    let mut v = start;
+    let mut guard = 0;
+    while v <= hi + step * 1e-9 && guard < 200 {
+        if v >= lo - step * 1e-9 && v <= hi + step * 1e-9 {
+            if v.abs() < step * 1e-9 {
+                out.push(0.0);
+            } else {
+                out.push(v);
+            }
+        }
+        v += step;
+        guard += 1;
+    }
+    out
+}
+
+fn draw_frame(xmin: f64, xmax: f64, ymin: f64, ymax: f64, style: PlotStyle) -> String {
+    let left = PAD;
+    let right = SVG_W - PAD;
+    let top = PAD;
+    let bottom = SVG_H - PAD;
+
+    let (ox, _) = map_xy(0.0, 0.0, xmin, xmax, ymin, ymax);
+    let (_, oy) = map_xy(0.0, 0.0, xmin, xmax, ymin, ymax);
+    let axis_x_y = if ymin <= 0.0 && ymax >= 0.0 {
+        oy.clamp(top, bottom)
+    } else if ymax < 0.0 {
+        top
+    } else {
+        bottom
+    };
+    let axis_y_x = if xmin <= 0.0 && xmax >= 0.0 {
+        ox.clamp(left, right)
+    } else if xmax < 0.0 {
+        right
+    } else {
+        left
+    };
+
+    let mut s = String::new();
+    let x_step = nice_step(xmax - xmin, 8);
+    let y_step = nice_step(ymax - ymin, 6);
+
+    if style.grid {
+        for x in tick_values(xmin, xmax, x_step) {
+            let (sx, _) = map_xy(x, 0.0, xmin, xmax, ymin, ymax);
+            if sx < left - 0.5 || sx > right + 0.5 {
+                continue;
+            }
+            s.push_str(&format!(
+                r#""#
+            ));
+        }
+        for y in tick_values(ymin, ymax, y_step) {
+            let (_, sy) = map_xy(0.0, y, xmin, xmax, ymin, ymax);
+            if sy < top - 0.5 || sy > bottom + 0.5 {
+                continue;
+            }
+            s.push_str(&format!(
+                r#""#
+            ));
+        }
+    }
+
+    // Axes with arrowheads (positive direction).
+    s.push_str(&format!(
+        r#""#
+    ));
+    s.push_str(&format!(
+        r#""#
+    ));
+
+    // Axis end labels
+    s.push_str(&format!(
+        r#"x"#,
+        x = right + 4.0,
+        y = axis_x_y + 4.0,
+    ));
+    s.push_str(&format!(
+        r#"y"#,
+        x = axis_y_x + 6.0,
+        y = top + 4.0,
+    ));
+
+    // Tick labels along axes (skip 0 clutter when both axes cross).
+    for x in tick_values(xmin, xmax, x_step) {
+        if x.abs() < x_step * 1e-9 {
+            continue;
+        }
+        let (sx, _) = map_xy(x, 0.0, xmin, xmax, ymin, ymax);
+        if sx < left || sx > right {
+            continue;
+        }
+        s.push_str(&format!(
+            r#""#,
+            y1 = axis_x_y - 4.0,
+            y2 = axis_x_y + 4.0,
+        ));
+        s.push_str(&format!(
+            r#"{label}"#,
+            ty = (axis_x_y + 14.0).min(bottom + 14.0),
+            label = super::format_num(x),
+        ));
+    }
+    for y in tick_values(ymin, ymax, y_step) {
+        if y.abs() < y_step * 1e-9 {
+            continue;
+        }
+        let (_, sy) = map_xy(0.0, y, xmin, xmax, ymin, ymax);
+        if sy < top || sy > bottom {
+            continue;
+        }
+        s.push_str(&format!(
+            r#""#,
+            x1 = axis_y_x - 4.0,
+            x2 = axis_y_x + 4.0,
+        ));
+        s.push_str(&format!(
+            r#"{label}"#,
+            tx = (axis_y_x - 8.0).max(4.0),
+            label = super::format_num(y),
+        ));
+    }
+
+    // Origin mark when visible
+    if xmin <= 0.0 && xmax >= 0.0 && ymin <= 0.0 && ymax >= 0.0 {
+        s.push_str(&format!(
+            r#"0"#,
+            x = axis_y_x - 8.0,
+            y = axis_x_y + 14.0,
+        ));
+    }
+
+    s
+}
+
+fn svg_wrap(body: &str, title: &str) -> String {
+    // r## so fill="#…" does not terminate the raw string at "#
+    format!(
+        r##"
+
+  
+    
+  
+
+
+{body}
+"##,
+        w = SVG_W,
+        h = SVG_H,
+        title = title,
+        body = body,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::formula::parse;
+
+    #[test]
+    fn plot_has_arrows_and_grid_by_default() {
+        let e = parse("x^2").unwrap();
+        let svg = plot_function_svg(&e, "x", -2.0, 2.0, 40, PlotStyle::default()).unwrap();
+        assert!(svg.contains("marker-end=\"url(#arrow)\""));
+        assert!(svg.contains("class=\"grid\""));
+        assert!(svg.contains(">x"));
+        assert!(svg.contains(">y"));
+    }
+
+    #[test]
+    fn plot_can_disable_grid() {
+        let e = parse("x").unwrap();
+        let svg = plot_function_svg(&e, "x", -1.0, 1.0, 20, PlotStyle { grid: false }).unwrap();
+        assert!(!svg.contains("class=\"grid\""));
+        assert!(svg.contains("marker-end=\"url(#arrow)\""));
+    }
+}
diff --git a/src/host/dispatch.rs b/src/host/dispatch.rs
index e1fb06e..1a0166f 100644
--- a/src/host/dispatch.rs
+++ b/src/host/dispatch.rs
@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 
-use crate::host::{fs, json, net, sys, time, HostContext};
+use crate::host::{fs, json, math, net, sys, time, HostContext};
 use crate::value::Value;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -33,6 +33,43 @@ pub enum HostFn {
     HttpGet = 23,
     HttpPost = 24,
     UrlEncode = 25,
+    // math
+    Pi = 26,
+    EConst = 27,
+    Num = 28,
+    MathAdd = 29,
+    MathSub = 30,
+    MathMul = 31,
+    MathDiv = 32,
+    MathPow = 33,
+    MathNeg = 34,
+    MathSin = 35,
+    MathCos = 36,
+    MathTan = 37,
+    MathAsin = 38,
+    MathAcos = 39,
+    MathAtan = 40,
+    MathSqrt = 41,
+    MathAbs = 42,
+    MathLn = 43,
+    MathExp = 44,
+    MathFloor = 45,
+    MathCeil = 46,
+    MathMin = 47,
+    MathMax = 48,
+    Random = 49,
+    RandomInt = 50,
+    Seed = 51,
+    Formula = 52,
+    Simplify = 53,
+    Expand = 54,
+    Diff = 55,
+    Subs = 56,
+    Eval = 57,
+    Solve = 58,
+    Plot = 59,
+    PlotPoints = 60,
+    PlotConic = 61,
 }
 
 impl HostFn {
@@ -63,6 +100,42 @@ impl HostFn {
             23 => Self::HttpGet,
             24 => Self::HttpPost,
             25 => Self::UrlEncode,
+            26 => Self::Pi,
+            27 => Self::EConst,
+            28 => Self::Num,
+            29 => Self::MathAdd,
+            30 => Self::MathSub,
+            31 => Self::MathMul,
+            32 => Self::MathDiv,
+            33 => Self::MathPow,
+            34 => Self::MathNeg,
+            35 => Self::MathSin,
+            36 => Self::MathCos,
+            37 => Self::MathTan,
+            38 => Self::MathAsin,
+            39 => Self::MathAcos,
+            40 => Self::MathAtan,
+            41 => Self::MathSqrt,
+            42 => Self::MathAbs,
+            43 => Self::MathLn,
+            44 => Self::MathExp,
+            45 => Self::MathFloor,
+            46 => Self::MathCeil,
+            47 => Self::MathMin,
+            48 => Self::MathMax,
+            49 => Self::Random,
+            50 => Self::RandomInt,
+            51 => Self::Seed,
+            52 => Self::Formula,
+            53 => Self::Simplify,
+            54 => Self::Expand,
+            55 => Self::Diff,
+            56 => Self::Subs,
+            57 => Self::Eval,
+            58 => Self::Solve,
+            59 => Self::Plot,
+            60 => Self::PlotPoints,
+            61 => Self::PlotConic,
             _ => return None,
         })
     }
@@ -94,6 +167,44 @@ impl HostFn {
             "host_http_get" => Self::HttpGet,
             "host_http_post" => Self::HttpPost,
             "host_url_encode" => Self::UrlEncode,
+            "host_pi" => Self::Pi,
+            "host_e" => Self::EConst,
+            "host_num" => Self::Num,
+            "host_math_add" => Self::MathAdd,
+            "host_math_sub" => Self::MathSub,
+            "host_math_mul" => Self::MathMul,
+            "host_math_div" => Self::MathDiv,
+            "host_math_pow" => Self::MathPow,
+            "host_math_neg" => Self::MathNeg,
+            "host_math_sin" => Self::MathSin,
+            "host_math_cos" => Self::MathCos,
+            "host_math_tan" => Self::MathTan,
+            "host_math_asin" => Self::MathAsin,
+            "host_math_acos" => Self::MathAcos,
+            "host_math_atan" => Self::MathAtan,
+            "host_math_sqrt" => Self::MathSqrt,
+            "host_math_abs" => Self::MathAbs,
+            "host_math_ln" => Self::MathLn,
+            "host_math_exp" => Self::MathExp,
+            "host_math_floor" => Self::MathFloor,
+            "host_math_ceil" => Self::MathCeil,
+            "host_math_min" => Self::MathMin,
+            "host_math_max" => Self::MathMax,
+            "host_random" => Self::Random,
+            "host_random_int" => Self::RandomInt,
+            "host_seed" => Self::Seed,
+            "host_formula" => Self::Formula,
+            "host_simplify" => Self::Simplify,
+            "host_expand" => Self::Expand,
+            "host_diff" => Self::Diff,
+            "host_subs" => Self::Subs,
+            "host_eval" => Self::Eval,
+            "host_solve" => Self::Solve,
+            // Friendly aliases so L1 `plot` / `绘图` get host optionals (`grid`, `path`, …)
+            // instead of thin wrappers that only forward required params.
+            "host_plot" | "plot" | "绘图" => Self::Plot,
+            "host_plot_points" | "plot_points" | "绘点列" => Self::PlotPoints,
+            "host_plot_conic" | "plot_conic" | "绘圆锥" => Self::PlotConic,
             _ => return None,
         })
     }
@@ -129,10 +240,45 @@ impl HostFn {
             Self::HttpGet => "host_http_get",
             Self::HttpPost => "host_http_post",
             Self::UrlEncode => "host_url_encode",
+            Self::Pi => "host_pi",
+            Self::EConst => "host_e",
+            Self::Num => "host_num",
+            Self::MathAdd => "host_math_add",
+            Self::MathSub => "host_math_sub",
+            Self::MathMul => "host_math_mul",
+            Self::MathDiv => "host_math_div",
+            Self::MathPow => "host_math_pow",
+            Self::MathNeg => "host_math_neg",
+            Self::MathSin => "host_math_sin",
+            Self::MathCos => "host_math_cos",
+            Self::MathTan => "host_math_tan",
+            Self::MathAsin => "host_math_asin",
+            Self::MathAcos => "host_math_acos",
+            Self::MathAtan => "host_math_atan",
+            Self::MathSqrt => "host_math_sqrt",
+            Self::MathAbs => "host_math_abs",
+            Self::MathLn => "host_math_ln",
+            Self::MathExp => "host_math_exp",
+            Self::MathFloor => "host_math_floor",
+            Self::MathCeil => "host_math_ceil",
+            Self::MathMin => "host_math_min",
+            Self::MathMax => "host_math_max",
+            Self::Random => "host_random",
+            Self::RandomInt => "host_random_int",
+            Self::Seed => "host_seed",
+            Self::Formula => "host_formula",
+            Self::Simplify => "host_simplify",
+            Self::Expand => "host_expand",
+            Self::Diff => "host_diff",
+            Self::Subs => "host_subs",
+            Self::Eval => "host_eval",
+            Self::Solve => "host_solve",
+            Self::Plot => "host_plot",
+            Self::PlotPoints => "host_plot_points",
+            Self::PlotConic => "host_plot_conic",
         }
     }
 
-    /// Required params first; see `optional_params` for trailing optionals.
     pub fn required_params(self) -> &'static [&'static str] {
         match self {
             Self::ReadText | Self::Exists | Self::ListDir | Self::MakeDir | Self::Remove => {
@@ -152,6 +298,20 @@ impl HostFn {
             Self::JsonGet => &["value", "key"],
             Self::HttpGet => &["url"],
             Self::HttpPost => &["url", "body"],
+            Self::Pi | Self::EConst | Self::Random => &[],
+            Self::Num | Self::MathNeg | Self::MathSin | Self::MathCos | Self::MathTan
+            | Self::MathAsin | Self::MathAcos | Self::MathAtan | Self::MathSqrt
+            | Self::MathAbs | Self::MathLn | Self::MathExp | Self::MathFloor | Self::MathCeil
+            | Self::Seed | Self::Formula | Self::Simplify | Self::Expand => &["value"],
+            Self::MathAdd | Self::MathSub | Self::MathMul | Self::MathDiv | Self::MathPow
+            | Self::MathMin | Self::MathMax => &["a", "b"],
+            Self::RandomInt => &["min", "max"],
+            Self::Diff => &["formula", "var"],
+            Self::Subs | Self::Eval => &["formula", "var", "value"],
+            Self::Solve => &["formula", "var"],
+            Self::Plot => &["formula", "var", "min", "max"],
+            Self::PlotPoints => &["xs", "ys"],
+            Self::PlotConic => &["kind", "a"],
         }
     }
 
@@ -160,6 +320,10 @@ impl HostFn {
             Self::JsonStringify => &["indent"],
             Self::HttpPost => &["content_type"],
             Self::Exec => &["args"],
+            Self::Solve => &["min", "max"],
+            Self::Plot => &["steps", "path", "derivative", "grid"],
+            Self::PlotPoints => &["path", "grid"],
+            Self::PlotConic => &["b", "h", "k", "path", "grid"],
             _ => &[],
         }
     }
@@ -172,7 +336,7 @@ impl HostFn {
 }
 
 pub fn call_host(
-    ctx: &HostContext,
+    ctx: &mut HostContext,
     fn_id: HostFn,
     bound: &HashMap,
 ) -> Result {
@@ -217,6 +381,82 @@ pub fn call_host(
             bound.get("content_type"),
         ),
         HostFn::UrlEncode => net::url_encode(require(bound, "text")?),
+        HostFn::Pi => math::pi(),
+        HostFn::EConst => math::e_const(),
+        HostFn::Num => math::to_num(require(bound, "value")?),
+        HostFn::MathAdd => math::binary_num("add", require(bound, "a")?, require(bound, "b")?),
+        HostFn::MathSub => math::binary_num("sub", require(bound, "a")?, require(bound, "b")?),
+        HostFn::MathMul => math::binary_num("mul", require(bound, "a")?, require(bound, "b")?),
+        HostFn::MathDiv => math::binary_num("div", require(bound, "a")?, require(bound, "b")?),
+        HostFn::MathPow => math::binary_num("pow", require(bound, "a")?, require(bound, "b")?),
+        HostFn::MathMin => math::binary_num("min", require(bound, "a")?, require(bound, "b")?),
+        HostFn::MathMax => math::binary_num("max", require(bound, "a")?, require(bound, "b")?),
+        HostFn::MathNeg => math::unary_num("neg", require(bound, "value")?),
+        HostFn::MathSin => math::unary_num("sin", require(bound, "value")?),
+        HostFn::MathCos => math::unary_num("cos", require(bound, "value")?),
+        HostFn::MathTan => math::unary_num("tan", require(bound, "value")?),
+        HostFn::MathAsin => math::unary_num("asin", require(bound, "value")?),
+        HostFn::MathAcos => math::unary_num("acos", require(bound, "value")?),
+        HostFn::MathAtan => math::unary_num("atan", require(bound, "value")?),
+        HostFn::MathSqrt => math::unary_num("sqrt", require(bound, "value")?),
+        HostFn::MathAbs => math::unary_num("abs", require(bound, "value")?),
+        HostFn::MathLn => math::unary_num("ln", require(bound, "value")?),
+        HostFn::MathExp => math::unary_num("exp", require(bound, "value")?),
+        HostFn::MathFloor => math::unary_num("floor", require(bound, "value")?),
+        HostFn::MathCeil => math::unary_num("ceil", require(bound, "value")?),
+        HostFn::Random => math::random(ctx),
+        HostFn::RandomInt => {
+            math::random_int(ctx, require(bound, "min")?, require(bound, "max")?)
+        }
+        HostFn::Seed => math::seed(ctx, require(bound, "value")?),
+        HostFn::Formula => math::formula_parse(require(bound, "value")?),
+        HostFn::Simplify => math::simplify(require(bound, "value")?),
+        HostFn::Expand => math::expand(require(bound, "value")?),
+        HostFn::Diff => math::diff(require(bound, "formula")?, require(bound, "var")?),
+        HostFn::Subs => math::subs(
+            require(bound, "formula")?,
+            require(bound, "var")?,
+            require(bound, "value")?,
+        ),
+        HostFn::Eval => math::eval_at(
+            require(bound, "formula")?,
+            require(bound, "var")?,
+            require(bound, "value")?,
+        ),
+        HostFn::Solve => math::solve(
+            require(bound, "formula")?,
+            require(bound, "var")?,
+            bound.get("min"),
+            bound.get("max"),
+        ),
+        HostFn::Plot => math::plot(
+            ctx,
+            require(bound, "formula")?,
+            require(bound, "var")?,
+            require(bound, "min")?,
+            require(bound, "max")?,
+            bound.get("steps"),
+            bound.get("path"),
+            bound.get("derivative"),
+            bound.get("grid"),
+        ),
+        HostFn::PlotPoints => math::plot_points(
+            ctx,
+            require(bound, "xs")?,
+            require(bound, "ys")?,
+            bound.get("path"),
+            bound.get("grid"),
+        ),
+        HostFn::PlotConic => math::plot_conic(
+            ctx,
+            require(bound, "kind")?,
+            require(bound, "a")?,
+            bound.get("b"),
+            bound.get("h"),
+            bound.get("k"),
+            bound.get("path"),
+            bound.get("grid"),
+        ),
     }
 }
 
diff --git a/src/host/json.rs b/src/host/json.rs
index 6d7b714..c7dacbd 100644
--- a/src/host/json.rs
+++ b/src/host/json.rs
@@ -60,6 +60,8 @@ fn json_to_value(v: &serde_json::Value) -> Result {
         serde_json::Value::Number(n) => {
             if let Some(i) = n.as_i64() {
                 Value::Int(i)
+            } else if let Some(f) = n.as_f64() {
+                Value::Num(f)
             } else {
                 Value::Text(n.to_string())
             }
@@ -87,6 +89,9 @@ fn value_to_json(v: &Value) -> Result {
         Value::None => serde_json::Value::Null,
         Value::Bool(b) => serde_json::Value::Bool(*b),
         Value::Int(n) => serde_json::Value::Number((*n).into()),
+        Value::Num(n) => serde_json::Number::from_f64(*n)
+            .map(serde_json::Value::Number)
+            .unwrap_or(serde_json::Value::Null),
         Value::Text(s) => serde_json::Value::String(s.clone()),
         Value::List(xs) => {
             let mut arr = Vec::with_capacity(xs.len());
@@ -102,5 +107,6 @@ fn value_to_json(v: &Value) -> Result {
             }
             serde_json::Value::Object(map)
         }
+        Value::Formula(e) => serde_json::Value::String(e.as_display()),
     })
 }
diff --git a/src/host/math.rs b/src/host/math.rs
new file mode 100644
index 0000000..e2a5bc6
--- /dev/null
+++ b/src/host/math.rs
@@ -0,0 +1,284 @@
+//! Host entry points for math / formula / random / plot.
+
+use std::collections::HashMap;
+
+use crate::formula::{self, Expr};
+use crate::host::fs;
+use crate::host::{HostContext, PlotArtifact};
+use crate::value::Value;
+
+pub fn as_f64(v: &Value) -> Result {
+    match v {
+        Value::Num(n) => Ok(*n),
+        Value::Int(n) => Ok(*n as f64),
+        Value::Text(s) => s
+            .trim()
+            .parse::()
+            .map_err(|_| format!("cannot convert to num: {s:?}")),
+        _ => Err("expected num (or int/text)".into()),
+    }
+}
+
+fn opt<'a>(v: Option<&'a Value>) -> Option<&'a Value> {
+    match v {
+        None | Some(Value::None) => None,
+        Some(v) => Some(v),
+    }
+}
+
+pub fn as_text(v: &Value) -> Result<&str, String> {
+    match v {
+        Value::Text(s) => Ok(s.as_str()),
+        _ => Err("expected text".into()),
+    }
+}
+
+pub fn as_bool(v: &Value) -> bool {
+    v.truthy()
+}
+
+pub fn formula_from_value(v: &Value) -> Result {
+    match v {
+        Value::Formula(e) => Ok(e.clone()),
+        Value::Text(s) => formula::parse(s),
+        Value::Num(n) => Ok(Expr::Num(*n)),
+        Value::Int(n) => Ok(Expr::Num(*n as f64)),
+        _ => Err("expected formula or expression text".into()),
+    }
+}
+
+fn num_val(n: f64) -> Value {
+    Value::Num(n)
+}
+
+pub fn pi() -> Result {
+    Ok(num_val(std::f64::consts::PI))
+}
+
+pub fn e_const() -> Result {
+    Ok(num_val(std::f64::consts::E))
+}
+
+pub fn to_num(v: &Value) -> Result {
+    Ok(num_val(as_f64(v)?))
+}
+
+pub fn unary_num(op: &str, x: &Value) -> Result {
+    let x = as_f64(x)?;
+    let y = match op {
+        "neg" => -x,
+        "sin" => x.sin(),
+        "cos" => x.cos(),
+        "tan" => x.tan(),
+        "asin" => x.asin(),
+        "acos" => x.acos(),
+        "atan" => x.atan(),
+        "sqrt" => x.sqrt(),
+        "abs" => x.abs(),
+        "ln" | "log" => x.ln(),
+        "exp" => x.exp(),
+        "floor" => x.floor(),
+        "ceil" => x.ceil(),
+        _ => return Err(format!("unknown unary math op `{op}`")),
+    };
+    Ok(num_val(y))
+}
+
+pub fn binary_num(op: &str, a: &Value, b: &Value) -> Result {
+    let a = as_f64(a)?;
+    let b = as_f64(b)?;
+    let y = match op {
+        "add" => a + b,
+        "sub" => a - b,
+        "mul" => a * b,
+        "div" => {
+            if b == 0.0 {
+                return Err("division by zero".into());
+            }
+            a / b
+        }
+        "pow" => a.powf(b),
+        "min" => a.min(b),
+        "max" => a.max(b),
+        _ => return Err(format!("unknown binary math op `{op}`")),
+    };
+    Ok(num_val(y))
+}
+
+pub fn seed(ctx: &mut HostContext, v: &Value) -> Result {
+    let n = as_f64(v)? as u64;
+    ctx.rng = n ^ 0xA5A5_A5A5_A5A5_A5A5;
+    if ctx.rng == 0 {
+        ctx.rng = 0xC0FFEE;
+    }
+    Ok(Value::None)
+}
+
+pub fn random(ctx: &mut HostContext) -> Result {
+    Ok(num_val(ctx.next_f64()))
+}
+
+pub fn random_int(ctx: &mut HostContext, lo: &Value, hi: &Value) -> Result {
+    let lo = as_f64(lo)? as i64;
+    let hi = as_f64(hi)? as i64;
+    if hi < lo {
+        return Err("random_int: max < min".into());
+    }
+    let span = (hi - lo + 1) as u64;
+    let r = ctx.next_u64() % span;
+    Ok(Value::Int(lo + r as i64))
+}
+
+pub fn formula_parse(text: &Value) -> Result {
+    let s = as_text(text)?;
+    Ok(Value::Formula(formula::parse(s)?))
+}
+
+pub fn simplify(v: &Value) -> Result {
+    Ok(Value::Formula(formula::simplify(&formula_from_value(v)?)))
+}
+
+pub fn expand(v: &Value) -> Result {
+    Ok(Value::Formula(formula::expand(&formula_from_value(v)?)))
+}
+
+pub fn diff(formula: &Value, var: &Value) -> Result {
+    let e = formula_from_value(formula)?;
+    let var = as_text(var)?;
+    Ok(Value::Formula(formula::diff(&e, var)))
+}
+
+pub fn subs(formula: &Value, var: &Value, value: &Value) -> Result {
+    let e = formula_from_value(formula)?;
+    let var = as_text(var)?;
+    let val = formula_from_value(value)?;
+    let out = formula::subs(&e, var, &val);
+    if let Expr::Num(n) = out {
+        Ok(num_val(n))
+    } else {
+        Ok(Value::Formula(out))
+    }
+}
+
+pub fn eval_at(formula: &Value, var: &Value, value: &Value) -> Result {
+    let e = formula_from_value(formula)?;
+    let var = as_text(var)?;
+    let x = as_f64(value)?;
+    let mut env = HashMap::new();
+    env.insert(var.to_string(), x);
+    Ok(num_val(formula::eval_f64(&e, &env)?))
+}
+
+pub fn solve(
+    formula: &Value,
+    var: &Value,
+    min: Option<&Value>,
+    max: Option<&Value>,
+) -> Result {
+    let e = formula_from_value(formula)?;
+    let var = as_text(var)?;
+    let xmin = opt(min).map(as_f64).transpose()?.unwrap_or(-100.0);
+    let xmax = opt(max).map(as_f64).transpose()?.unwrap_or(100.0);
+    let roots = formula::solve(&e, var, xmin, xmax)?;
+    Ok(Value::List(roots.into_iter().map(num_val).collect()))
+}
+
+fn maybe_write_plot(
+    ctx: &mut HostContext,
+    path: Option<&Value>,
+    svg: String,
+) -> Result {
+    let path_s = match opt(path) {
+        Some(v) => Some(as_text(v)?.to_string()),
+        None => None,
+    };
+    if let Some(ref p) = path_s {
+        fs::write_text(ctx, &Value::Text(p.clone()), &Value::Text(svg.clone()))?;
+    }
+    ctx.plots.push(PlotArtifact {
+        path: path_s,
+        svg: svg.clone(),
+    });
+    Ok(Value::Text(svg))
+}
+
+fn plot_style(grid: Option<&Value>) -> Result {
+    let grid = match opt(grid) {
+        None => true,
+        Some(v) => as_bool(v),
+    };
+    Ok(formula::PlotStyle { grid })
+}
+
+pub fn plot(
+    ctx: &mut HostContext,
+    formula: &Value,
+    var: &Value,
+    min: &Value,
+    max: &Value,
+    steps: Option<&Value>,
+    path: Option<&Value>,
+    derivative: Option<&Value>,
+    grid: Option<&Value>,
+) -> Result {
+    let mut e = formula_from_value(formula)?;
+    let var_s = as_text(var)?;
+    if opt(derivative).map(as_bool).unwrap_or(false) {
+        e = formula::diff(&e, var_s);
+    }
+    let xmin = as_f64(min)?;
+    let xmax = as_f64(max)?;
+    let steps = match opt(steps) {
+        Some(v) => as_f64(v)? as usize,
+        None => 200,
+    };
+    let style = plot_style(grid)?;
+    let svg = formula::plot_function_svg(&e, var_s, xmin, xmax, steps, style)?;
+    maybe_write_plot(ctx, path, svg)
+}
+
+pub fn plot_points(
+    ctx: &mut HostContext,
+    xs: &Value,
+    ys: &Value,
+    path: Option<&Value>,
+    grid: Option<&Value>,
+) -> Result {
+    let xs = match xs {
+        Value::List(xs) => xs
+            .iter()
+            .map(as_f64)
+            .collect::, _>>()?,
+        _ => return Err("plot_points needs list xs".into()),
+    };
+    let ys = match ys {
+        Value::List(ys) => ys
+            .iter()
+            .map(as_f64)
+            .collect::, _>>()?,
+        _ => return Err("plot_points needs list ys".into()),
+    };
+    let style = plot_style(grid)?;
+    let svg = formula::plot_points_svg(&xs, &ys, style)?;
+    maybe_write_plot(ctx, path, svg)
+}
+
+pub fn plot_conic(
+    ctx: &mut HostContext,
+    kind: &Value,
+    a: &Value,
+    b: Option<&Value>,
+    h: Option<&Value>,
+    k: Option<&Value>,
+    path: Option<&Value>,
+    grid: Option<&Value>,
+) -> Result {
+    let kind = as_text(kind)?;
+    let a = as_f64(a)?;
+    let b = opt(b).map(as_f64).transpose()?.unwrap_or(a);
+    let h = opt(h).map(as_f64).transpose()?.unwrap_or(0.0);
+    let k = opt(k).map(as_f64).transpose()?.unwrap_or(0.0);
+    let style = plot_style(grid)?;
+    let svg = formula::plot_conic_svg(kind, a, b, h, k, style)?;
+    maybe_write_plot(ctx, path, svg)
+}
diff --git a/src/host/mod.rs b/src/host/mod.rs
index 12bce24..461dcca 100644
--- a/src/host/mod.rs
+++ b/src/host/mod.rs
@@ -1,4 +1,4 @@
-//! L0.5 host primitives for official stdlib (`lib/fs`, `time`, …).
+//! L0.5 host primitives for official stdlib (`lib/fs`, `time`, `math`, …).
 //!
 //! User docs should import L1 wrappers; these `host_*` names are the Rust surface.
 //! Capabilities default **on** (importing a lib means you intend to use it).
@@ -7,6 +7,7 @@
 mod dispatch;
 mod fs;
 mod json;
+pub mod math;
 mod net;
 mod sys;
 mod time;
@@ -34,6 +35,14 @@ impl Default for HostCaps {
     }
 }
 
+/// SVG plot produced during a run (for CLI auto-write / view embed).
+#[derive(Debug, Clone)]
+pub struct PlotArtifact {
+    /// User-requested path, if any.
+    pub path: Option,
+    pub svg: String,
+}
+
 #[derive(Debug, Clone)]
 pub struct HostContext {
     pub caps: HostCaps,
@@ -43,6 +52,9 @@ pub struct HostContext {
     /// Soft mode: do not `process::exit`; honor sleep_limit (view / capture / export).
     pub soft_side_effects: bool,
     pub sleep_limit_ms: Option,
+    /// LCG state for `random` / `random_int`.
+    pub rng: u64,
+    pub plots: Vec,
 }
 
 impl Default for HostContext {
@@ -54,6 +66,8 @@ impl Default for HostContext {
             argv: Vec::new(),
             soft_side_effects: false,
             sleep_limit_ms: Some(30_000),
+            rng: 0xC0FF_EE42_CAFE_BABE,
+            plots: Vec::new(),
         }
     }
 }
@@ -97,6 +111,23 @@ impl HostContext {
         self.caps.net
     }
 
+    pub fn next_u64(&mut self) -> u64 {
+        // SplitMix64-ish LCG step
+        self.rng = self
+            .rng
+            .wrapping_mul(6364136223846793005)
+            .wrapping_add(1);
+        let mut z = self.rng;
+        z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
+        z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
+        z ^ (z >> 31)
+    }
+
+    pub fn next_f64(&mut self) -> f64 {
+        let x = self.next_u64() >> 11;
+        (x as f64) / ((1u64 << 53) as f64)
+    }
+
     pub fn resolve_path(&self, rel: &str) -> Result {
         let p = Path::new(rel);
         let abs = if p.is_absolute() {
@@ -124,3 +155,28 @@ impl HostContext {
         Ok(abs)
     }
 }
+
+/// Write auto-named plot files for CLI runs when `path` was omitted.
+pub fn flush_auto_plots(source_path: Option<&Path>, plots: &[PlotArtifact]) -> Result<(), String> {
+    let mut auto_i = 0usize;
+    for plot in plots {
+        if plot.path.is_some() {
+            continue;
+        }
+        auto_i += 1;
+        let stem = source_path
+            .and_then(|p| p.file_stem())
+            .and_then(|s| s.to_str())
+            .unwrap_or("out");
+        let stem = stem.trim_end_matches(".mq");
+        let name = format!("{stem}-plot-{auto_i}.svg");
+        let dir = source_path
+            .and_then(|p| p.parent())
+            .unwrap_or_else(|| Path::new("."));
+        let dest = dir.join(&name);
+        std::fs::write(&dest, plot.svg.as_bytes())
+            .map_err(|e| format!("failed to write plot {}: {e}", dest.display()))?;
+        println!("plot: {}", dest.display());
+    }
+    Ok(())
+}
diff --git a/src/interp.rs b/src/interp.rs
index 0bfbb74..8344cc2 100644
--- a/src/interp.rs
+++ b/src/interp.rs
@@ -87,6 +87,10 @@ impl Interpreter {
         self
     }
 
+    pub fn take_plots(&mut self) -> Vec {
+        std::mem::take(&mut self.host.plots)
+    }
+
     fn err(&self, message: impl Into) -> anyhow::Error {
         bail_at(self.path.as_deref(), self.current_span, message)
     }
@@ -181,7 +185,7 @@ impl Interpreter {
         stmt: &Stmt,
     ) -> Result> {
         match stmt {
-            Stmt::Assign { name, value, span } => {
+            Stmt::Assign { name, value, span, .. } => {
                 self.current_span = *span;
                 let v = self.eval_expr(module, fun, env, value)?;
                 if self.trace {
@@ -390,6 +394,7 @@ impl Interpreter {
                 }
                 Ok(Value::List(out))
             }
+            Expr::Formula(e) => Ok(Value::Formula(e.clone())),
         }
     }
 
@@ -539,7 +544,7 @@ impl Interpreter {
                         return Err(self.err(format!("{} requires `{req}`", hf.name())));
                     }
                 }
-                return call_host(&self.host, hf, &bound).map_err(|m| self.err(m));
+                return call_host(&mut self.host, hf, &bound).map_err(|m| self.err(m));
             }
             _ => {}
         }
@@ -680,7 +685,14 @@ fn eval_binary(op: BinaryOp, l: &Value, r: &Value) -> Result {
 fn cmp_ord(l: &Value, r: &Value, f: impl Fn(std::cmp::Ordering) -> bool) -> Result {
     match (l, r) {
         (Value::Int(a), Value::Int(b)) => Ok(Value::Bool(f(a.cmp(b)))),
+        (Value::Num(a), Value::Num(b)) => Ok(Value::Bool(f(a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)))),
+        (Value::Int(a), Value::Num(b)) => {
+            Ok(Value::Bool(f((*a as f64).partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))))
+        }
+        (Value::Num(a), Value::Int(b)) => {
+            Ok(Value::Bool(f(a.partial_cmp(&(*b as f64)).unwrap_or(std::cmp::Ordering::Equal))))
+        }
         (Value::Text(a), Value::Text(b)) => Ok(Value::Bool(f(a.cmp(b)))),
-        _ => bail!("comparison needs two ints or two texts"),
+        _ => bail!("comparison needs two ints/nums or two texts"),
     }
 }
diff --git a/src/lex/mod.rs b/src/lex/mod.rs
index fcd2976..2496dd5 100644
--- a/src/lex/mod.rs
+++ b/src/lex/mod.rs
@@ -36,7 +36,7 @@ pub struct ClassifiedLine {
 fn is_code_starter(c: char) -> bool {
     matches!(
         c,
-        '#' | '*' | '>' | '+' | '-' | '`' | '|' | '~'
+        '#' | '*' | '>' | '+' | '-' | '`' | '|' | '~' | '$'
     ) || c.is_ascii_digit()
 }
 
@@ -72,26 +72,40 @@ pub fn classify_source(source: &str) -> Vec {
 
     let mut out = Vec::with_capacity(lines.len());
     let mut in_comment_paragraph = false;
+    let mut in_math_fence = false;
 
     for (i, text) in lines.into_iter().enumerate() {
         let base = classify_line(text);
         let trimmed = text.trim();
         let structural = is_structural_code_line(trimmed);
-        let kind = match base {
-            LineKind::Blank => {
-                in_comment_paragraph = false;
-                LineKind::Blank
+        let kind = if in_math_fence {
+            if trimmed == "$$" {
+                in_math_fence = false;
             }
-            LineKind::Comment => {
-                in_comment_paragraph = true;
-                LineKind::Comment
+            LineKind::Code
+        } else {
+            match base {
+                LineKind::Blank => {
+                    in_comment_paragraph = false;
+                    LineKind::Blank
+                }
+                LineKind::Comment => {
+                    in_comment_paragraph = true;
+                    LineKind::Comment
+                }
+                LineKind::Code if structural => {
+                    in_comment_paragraph = false;
+                    LineKind::Code
+                }
+                LineKind::Code if in_comment_paragraph => LineKind::Comment,
+                LineKind::Code => {
+                    // Multi-line math fence opener (not same-line `$$…$$`).
+                    if trimmed == "$$" {
+                        in_math_fence = true;
+                    }
+                    LineKind::Code
+                }
             }
-            LineKind::Code if structural => {
-                in_comment_paragraph = false;
-                LineKind::Code
-            }
-            LineKind::Code if in_comment_paragraph => LineKind::Comment,
-            LineKind::Code => LineKind::Code,
         };
         out.push(ClassifiedLine {
             line_no: (i + 1) as u32,
@@ -186,4 +200,15 @@ mod tests {
         assert!(lines.iter().any(|l| l.kind == LineKind::Comment));
         assert!(lines.iter().any(|l| l.kind == LineKind::Code));
     }
+
+    #[test]
+    fn math_fence_body_stays_code() {
+        let lines = classify_source("`f` =\n$$\nx^2 - 2\n$$\n");
+        assert!(
+            lines
+                .iter()
+                .all(|l| l.kind == LineKind::Code || l.kind == LineKind::Blank),
+            "expected fence body as Code, got {lines:?}"
+        );
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 87abde4..df27dab 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -11,6 +11,7 @@ pub mod capture;
 pub mod catalog;
 pub mod debug;
 pub mod diagnostics;
+pub mod formula;
 pub mod host;
 pub mod input_feed;
 pub mod interp;
@@ -24,7 +25,7 @@ use std::path::Path;
 
 use anyhow::{bail, Result};
 
-use crate::host::{HostCaps, HostContext};
+use crate::host::{flush_auto_plots, HostCaps, HostContext};
 use crate::ast::format_ast_dump;
 use crate::bytecode::{compile_module, Vm};
 use crate::capture::RunCapture;
@@ -178,6 +179,8 @@ pub fn run_file(path: &Path, opts: &RunOptions) -> Result {
             if opts.trace_eval {
                 eprintln!("=== marqdo: end trace-eval ===");
             }
+            let plots = interp.take_plots();
+            flush_auto_plots(Some(path), &plots).map_err(|e| anyhow::anyhow!(e))?;
         }
         Backend::Bytecode => {
             let program = compile_module(Some(path), &module)?;
@@ -196,6 +199,8 @@ pub fn run_file(path: &Path, opts: &RunOptions) -> Result {
             if opts.trace_eval {
                 eprintln!("=== marqdo: end trace-eval ===");
             }
+            let plots = vm.take_plots();
+            flush_auto_plots(Some(path), &plots).map_err(|e| anyhow::anyhow!(e))?;
         }
     }
 
@@ -228,9 +233,11 @@ pub fn run_file_capture(path: &Path, opts: &RunOptions) -> Result {
                 .with_stdin(stdin_lines)
                 .with_host(host);
             let value = interp.run_module(&module)?;
+            let plots = interp.take_plots();
             Ok(RunCapture {
                 stdout: interp.captured_stdout,
                 value,
+                plots,
             })
         }
         Backend::Bytecode => {
@@ -247,9 +254,11 @@ pub fn run_file_capture(path: &Path, opts: &RunOptions) -> Result {
                 .with_stdin(stdin_lines)
                 .with_host(host);
             let value = vm.run(&program)?;
+            let plots = vm.take_plots();
             Ok(RunCapture {
                 stdout: vm.captured_stdout,
                 value,
+                plots,
             })
         }
     }
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index e85986e..4497640 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -206,6 +206,13 @@ impl<'a> Cursor<'a> {
             bail!("{span}: unexpected frame line as statement");
         }
 
+        if trimmed.starts_with("$$") {
+            bail!(
+                "{span}: formula fence must follow an empty assignment (`name` =); \
+                 `$$:name` binding was removed"
+            );
+        }
+
         // Bold return **…** (empty inner → None)
         if trimmed.starts_with("**") && trimmed.ends_with("**") && trimmed.len() >= 4 {
             let inner = &trimmed[2..trimmed.len() - 2];
@@ -220,7 +227,7 @@ impl<'a> Cursor<'a> {
         // Italic statement *…*
         if trimmed.starts_with('*') && trimmed.ends_with('*') && !trimmed.starts_with("**") {
             let inner = &trimmed[1..trimmed.len() - 1];
-            return parse_assign_or_expr_stmt(inner, span);
+            return self.parse_italic_assign(inner, span);
         }
 
         // Call >
@@ -229,7 +236,7 @@ impl<'a> Cursor<'a> {
             return Ok(Stmt::Call { call, span });
         }
 
-        // Bare assign `` `x` = … `` possibly followed by table
+        // Bare assign `` `x` = … `` possibly followed by formula fence or table
         if trimmed.starts_with('`') {
             if let Some(stmt) = self.parse_backtick_assign(trimmed, span.clone())? {
                 return Ok(stmt);
@@ -239,6 +246,22 @@ impl<'a> Cursor<'a> {
         Err(Diagnostic::new(None, span, format!("unrecognized statement: {trimmed}")).into())
     }
 
+    fn parse_italic_assign(&mut self, inner: &str, span: Span) -> Result {
+        let Some((name, rhs)) = split_assign_inner(inner) else {
+            bail!("{span}: italic statement must be an assignment (`name` = …)");
+        };
+        if crate::aliases::is_reserved_keyword(&name) {
+            bail!("{span}: `{name}` is a reserved keyword");
+        }
+        let (value, end_line) = self.resolve_assign_rhs(&rhs, span)?;
+        Ok(Stmt::Assign {
+            name,
+            value,
+            span,
+            end_line,
+        })
+    }
+
     fn parse_backtick_assign(&mut self, trimmed: &str, span: Span) -> Result> {
         // `name` = [rhs]
         let Some(rest) = trimmed.strip_prefix('`') else {
@@ -255,23 +278,114 @@ impl<'a> Cursor<'a> {
         if !after.starts_with('=') {
             return Ok(None);
         }
-        let rhs = after[1..].trim();
-        if rhs.is_empty() {
-            // Consume following table if present.
-            let list = self.consume_table()?;
-            return Ok(Some(Stmt::Assign {
-                name,
-                value: Expr::List(list.into_iter().map(Expr::Literal).collect()),
-                span,
-            }));
-        }
+        let rhs = after[1..].trim().to_string();
+        let (value, end_line) = self.resolve_assign_rhs(&rhs, span)?;
         Ok(Some(Stmt::Assign {
             name,
-            value: parse_value_or_interp(rhs)?,
+            value,
             span,
+            end_line,
         }))
     }
 
+    /// RHS on the same line, or empty RHS → following `$$` fence or table.
+    /// Returns `(expr, inclusive end_line)`.
+    fn resolve_assign_rhs(&mut self, rhs: &str, span: Span) -> Result<(Expr, u32)> {
+        let rhs = rhs.trim();
+        if rhs.is_empty() {
+            self.skip_blanks();
+            if self.peek_is_formula_fence() {
+                return self.consume_formula_fence(span);
+            }
+            let start_i = self.i;
+            let list = self.consume_table()?;
+            let end_line = if self.i > start_i {
+                self.lines[self.i - 1].line_no
+            } else {
+                span.line
+            };
+            return Ok((
+                Expr::List(list.into_iter().map(Expr::Literal).collect()),
+                end_line,
+            ));
+        }
+        if let Some(expr) = try_parse_inline_formula(rhs)? {
+            return Ok((expr, span.line));
+        }
+        if rhs.starts_with('>') {
+            return Ok((Expr::Call(call_after_gt(rhs[1..].trim())?), span.line));
+        }
+        Ok((parse_value_or_interp(rhs)?, span.line))
+    }
+
+    fn skip_blanks(&mut self) {
+        while let Some(l) = self.peek() {
+            if l.kind == LineKind::Blank {
+                self.i += 1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn peek_is_formula_fence(&self) -> bool {
+        self.peek()
+            .map(|l| l.text.trim().starts_with("$$"))
+            .unwrap_or(false)
+    }
+
+    fn consume_formula_fence(&mut self, span: Span) -> Result<(Expr, u32)> {
+        let open = self
+            .bump()
+            .ok_or_else(|| anyhow::anyhow!("{span}: expected `$$` formula fence"))?;
+        let open_line = open.line_no;
+        let trimmed = open.text.trim();
+        if trimmed.starts_with("$$:") || trimmed.starts_with("$$ name=") {
+            bail!(
+                "{open_line}:1: `$$:name` / `$$ name=` binding was removed; \
+                 use `name` = then a `$$…$$` fence"
+            );
+        }
+        // Single-line: $$body$$
+        if trimmed.starts_with("$$") && trimmed.ends_with("$$") && trimmed.len() > 4 {
+            let body = trimmed[2..trimmed.len() - 2].trim();
+            if body.is_empty() {
+                bail!("{open_line}:1: empty formula");
+            }
+            let expr = crate::formula::parse(body)
+                .map_err(|e| anyhow::anyhow!("{open_line}:1: formula: {e}"))?;
+            return Ok((Expr::Formula(expr), open_line));
+        }
+        if trimmed != "$$" {
+            bail!(
+                "{open_line}:1: expected `$$` fence opener after empty assignment, got: {trimmed}"
+            );
+        }
+        let mut body_lines: Vec = Vec::new();
+        let mut closed = false;
+        let mut end_line = open_line;
+        while let Some(l) = self.peek() {
+            if l.text.trim() == "$$" {
+                end_line = l.line_no;
+                self.bump();
+                closed = true;
+                break;
+            }
+            body_lines.push(l.text.clone());
+            self.bump();
+        }
+        if !closed {
+            bail!("{open_line}:1: unclosed formula fence `$$`");
+        }
+        let text = body_lines.join("\n").trim().to_string();
+        if text.is_empty() {
+            bail!("{open_line}:1: empty formula");
+        }
+        let expr = crate::formula::parse(&text)
+            .map_err(|e| anyhow::anyhow!("{open_line}:1: formula: {e}"))?;
+        Ok((Expr::Formula(expr), end_line))
+    }
+
     fn consume_table(&mut self) -> Result> {
         self.skip_noise();
         let mut rows = Vec::new();
@@ -416,33 +530,36 @@ impl<'a> Cursor<'a> {
     }
 }
 
-fn parse_assign_or_expr_stmt(inner: &str, span: Span) -> Result {
+fn split_assign_inner(inner: &str) -> Option<(String, String)> {
     let inner = inner.trim();
-    // `` `name` = … ``
-    if let Some(rest) = inner.strip_prefix('`') {
-        if let Some(end) = rest.find('`') {
-            let name = rest[..end].to_string();
-            if crate::aliases::is_reserved_keyword(&name) {
-                bail!("{span}: `{name}` is a reserved keyword");
-            }
-            let after = rest[end + 1..].trim_start();
-            if let Some(rhs) = after.strip_prefix('=') {
-                let rhs = rhs.trim();
-                // Inline call assign: `> fn …`
-                let value = if rhs.starts_with('>') {
-                    Expr::Call(call_after_gt(rhs[1..].trim())?)
-                } else {
-                    parse_value_or_interp(rhs)?
-                };
-                return Ok(Stmt::Assign {
-                    name,
-                    value,
-                    span,
-                });
-            }
-        }
+    let rest = inner.strip_prefix('`')?;
+    let end = rest.find('`')?;
+    let name = rest[..end].to_string();
+    let after = rest[end + 1..].trim_start();
+    let rhs = after.strip_prefix('=')?.trim().to_string();
+    Some((name, rhs))
+}
+
+/// Same-line `$$body$$` → Formula; otherwise None (caller parses normally).
+fn try_parse_inline_formula(rhs: &str) -> Result> {
+    let rhs = rhs.trim();
+    if !rhs.starts_with("$$") {
+        return Ok(None);
     }
-    bail!("{span}: italic statement must be an assignment (`name` = …)")
+    if rhs.starts_with("$$:") || rhs.starts_with("$$ name=") {
+        bail!(
+            "`$$:name` / `$$ name=` binding was removed; use `name` = then a `$$…$$` fence"
+        );
+    }
+    if rhs.ends_with("$$") && rhs.len() > 4 {
+        let body = rhs[2..rhs.len() - 2].trim();
+        if body.is_empty() {
+            bail!("empty formula");
+        }
+        let expr = crate::formula::parse(body).map_err(|e| anyhow::anyhow!("formula: {e}"))?;
+        return Ok(Some(Expr::Formula(expr)));
+    }
+    bail!("incomplete inline formula (expected `$$…$$` on one line)");
 }
 
 fn parse_param_line(trimmed: &str) -> Option {
@@ -588,4 +705,24 @@ mod tests {
         let main = &m.functions[0];
         assert!(main.body.iter().any(|s| matches!(s, Stmt::Branch { .. })));
     }
+
+    #[test]
+    fn parse_formula_assign_fence() {
+        let src = "# main\n\n`f` =\n$$\nx^2 - 2\n$$\n\n> print text=`f`\n";
+        let m = parse_source(src).unwrap();
+        let body = &m.functions[0].body;
+        match &body[0] {
+            Stmt::Assign {
+                name,
+                value: Expr::Formula(e),
+                end_line,
+                ..
+            } => {
+                assert_eq!(name, "f");
+                assert_eq!(e.as_display(), "x^2 - 2");
+                assert!(*end_line > 3, "end_line should cover the fence, got {end_line}");
+            }
+            other => panic!("expected formula assign, got {other:?}"),
+        }
+    }
 }
diff --git a/src/value.rs b/src/value.rs
index 103522b..e586d8e 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -2,16 +2,22 @@
 
 use std::fmt;
 
+use crate::formula::Expr as FormulaExpr;
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum Value {
     None,
     Bool(bool),
     Int(i64),
+    /// Floating-point number (`type` → `num`).
+    Num(f64),
     Text(String),
     /// Single-column table rows (v0); multi-column later.
     List(Vec),
     /// JSON object / string-keyed map (insertion order).
     Map(Vec<(String, Value)>),
+    /// Parsed symbolic expression (`type` → `formula`).
+    Formula(FormulaExpr),
 }
 
 impl Value {
@@ -20,9 +26,11 @@ impl Value {
             Value::None => false,
             Value::Bool(b) => *b,
             Value::Int(n) => *n != 0,
+            Value::Num(n) => *n != 0.0 && !n.is_nan(),
             Value::Text(s) => !s.is_empty(),
             Value::List(xs) => !xs.is_empty(),
             Value::Map(xs) => !xs.is_empty(),
+            Value::Formula(_) => true,
         }
     }
 
@@ -32,9 +40,14 @@ impl Value {
             Value::Bool(true) => "True".into(),
             Value::Bool(false) => "False".into(),
             Value::Int(n) => n.to_string(),
+            Value::Num(n) => crate::formula::format_num(*n),
             Value::Text(s) => s.clone(),
-            Value::List(_) => "".into(),
+            Value::List(xs) => {
+                let parts: Vec = xs.iter().map(|v| v.as_display()).collect();
+                format!("[{}]", parts.join(", "))
+            }
             Value::Map(_) => "".into(),
+            Value::Formula(e) => e.as_display(),
         }
     }
 }
diff --git a/src/view/html.rs b/src/view/html.rs
index f8ad7df..830ae77 100644
--- a/src/view/html.rs
+++ b/src/view/html.rs
@@ -169,12 +169,49 @@ a:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
   opacity: 1;
   font-weight: 500;
 }
+.nav-root { margin: 0; padding: 0; list-style: none; }
 .folder {
+  margin: 0.55rem 0 0.2rem;
+  border: none;
+}
+.folder > summary {
+  list-style: none;
+  cursor: pointer;
+  user-select: none;
   color: var(--muted);
   font-size: 0.72rem;
-  margin: 1rem 0.35rem 0.35rem;
   font-weight: 600;
   letter-spacing: 0.01em;
+  padding: 0.35rem 0.45rem;
+  border-radius: 8px;
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+  transition: background 0.12s ease, color 0.12s ease;
+}
+.folder > summary::-webkit-details-marker { display: none; }
+.folder > summary::before {
+  content: "";
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 4px 0 4px 6px;
+  border-color: transparent transparent transparent var(--muted);
+  opacity: 0.85;
+  transition: transform 0.12s ease;
+  flex-shrink: 0;
+}
+.folder[open] > summary::before {
+  transform: rotate(90deg);
+}
+.folder > summary:hover {
+  background: var(--hover);
+  color: var(--ink);
+}
+.folder > ul {
+  list-style: none;
+  padding: 0.1rem 0 0.15rem 0.55rem;
+  margin: 0;
 }
 .panel-wrap {
   min-width: 0;
@@ -231,7 +268,7 @@ section.block > h2 {
 }
 .stdin-form label {
   font-size: 0.85rem;
-  color: var(--text);
+  color: var(--ink);
 }
 .stdin-form .hint {
   color: var(--muted);
@@ -243,10 +280,10 @@ section.block > h2 {
   font-family: var(--mono);
   font-size: 0.9rem;
   padding: 0.65rem 0.75rem;
-  border: 1px solid var(--border);
+  border: 1px solid var(--line);
   border-radius: 8px;
   background: var(--surface);
-  color: var(--text);
+  color: var(--ink);
   resize: vertical;
   min-height: 4.5rem;
 }
@@ -254,14 +291,19 @@ section.block > h2 {
   justify-self: start;
   font: inherit;
   font-size: 0.9rem;
-  padding: 0.45rem 0.9rem;
-  border: 1px solid var(--border);
+  font-weight: 600;
+  padding: 0.5rem 1rem;
+  border: 1px solid var(--ink);
   border-radius: 8px;
-  background: var(--text);
-  color: var(--bg);
+  background: var(--ink);
+  color: #ffffff;
   cursor: pointer;
 }
 .stdin-form button:hover { opacity: 0.88; }
+.stdin-form button:focus-visible {
+  outline: 2px solid var(--focus);
+  outline-offset: 2px;
+}
 .structure {
   background: var(--surface);
   border: 1px solid var(--line);
@@ -342,6 +384,38 @@ section.block > h2 {
   color: var(--ink);
   font-weight: 500;
 }
+.formula-card .math-block {
+  display: inline-block;
+  margin: 0.25rem 0 0.1rem 0.25rem;
+  vertical-align: middle;
+  overflow-x: auto;
+  max-width: 100%;
+}
+.formula-card .katex-display {
+  margin: 0.2rem 0;
+}
+.plots {
+  display: grid;
+  gap: 1rem;
+  margin-top: 1rem;
+  justify-items: center;
+}
+.plot {
+  overflow: auto;
+  background: var(--surface);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 0.75rem;
+  width: 100%;
+  display: flex;
+  justify-content: center;
+}
+.plot svg {
+  display: block;
+  max-width: 100%;
+  height: auto;
+  margin-inline: auto;
+}
 .comment-text {
   color: var(--muted);
   font-size: 0.92rem;
@@ -439,6 +513,7 @@ pub fn layout(title: &str, nav: &str, main: &str) -> String {
 
 
 
+
 
 
 
@@ -470,6 +545,9 @@ pub fn layout(title: &str, nav: &str, main: &str) -> String {
 
 
 
+
+
 
 
 "##,
@@ -481,23 +559,22 @@ pub fn layout(title: &str, nav: &str, main: &str) -> String {
 }
 
 pub fn nav_html(files: &[PathBuf], active: Option<&str>, links: &LinkMode) -> String {
-    let mut out = String::from("

Files

    "); - let mut last_folder = String::new(); + let mut out = String::from("

    Files

    "); + let mut last_folder: Option = None; + for f in files { let rel = f.to_string_lossy().replace('\\', "/"); let folder = Path::new(&rel) .parent() - .map(|p| p.to_string_lossy().to_string()) + .map(|p| p.to_string_lossy().replace('\\', "/")) .unwrap_or_default(); - if folder != last_folder { - if !folder.is_empty() { - out.push_str(&format!( - "
{}
    ", - escape(&folder) - )); - } - last_folder = folder; + + if last_folder.as_deref() != Some(folder.as_str()) { + close_nav_group(&mut out, last_folder.as_deref()); + open_nav_group(&mut out, &folder, active); + last_folder = Some(folder); } + let name = Path::new(&rel) .file_name() .and_then(|s| s.to_str()) @@ -514,7 +591,8 @@ pub fn nav_html(files: &[PathBuf], active: Option<&str>, links: &LinkMode) -> St escape(name) )); } - out.push_str("
"); + close_nav_group(&mut out, last_folder.as_deref()); + // index link for static pages if matches!(links, LinkMode::Static { from: Some(_) }) { let home = href_index(links); @@ -529,6 +607,37 @@ pub fn nav_html(files: &[PathBuf], active: Option<&str>, links: &LinkMode) -> St out } +fn close_nav_group(out: &mut String, folder: Option<&str>) { + match folder { + None => {} + Some("") => out.push_str(""), + Some(_) => out.push_str(""), + } +} + +fn open_nav_group(out: &mut String, folder: &str, active: Option<&str>) { + if folder.is_empty() { + out.push_str("
    "); + return; + } + let contains_active = active.is_some_and(|a| { + Path::new(a) + .parent() + .map(|p| p.to_string_lossy().replace('\\', "/") == folder) + .unwrap_or(false) + }); + // Index (no active): keep folders open for browsing; else open only the active folder. + let open_attr = if active.is_none() || contains_active { + " open" + } else { + "" + }; + out.push_str(&format!( + "
    {}
      ", + escape(folder) + )); +} + fn href_file(links: &LinkMode, target_rel: &str) -> String { match links { LinkMode::Live => format!("/file?path={}", urlencoding_encode(target_rel)), @@ -620,27 +729,47 @@ pub fn page_file(files: &[PathBuf], rel: &str, vm: &FileViewModel, links: &LinkM } else { escape(&vm.stderr) }; - let stdin_panel = match links { - LinkMode::Live => format!( - r#"
      + let stdin_panel = if vm.input_prompts.is_empty() { + String::new() + } else { + let placeholder = vm.input_prompts.join("\n"); + let rows = vm.input_prompts.len().clamp(2, 8); + match links { + LinkMode::Live => { + let hint = if vm.input_prompts.iter().any(|p| !p.is_empty()) { + format!( + "prompts: {}", + escape(&vm.input_prompts.join(" · ")) + ) + } else { + "one line per input".into() + }; + format!( + r#" - - + +
      "#, - path = escape(rel), - stdin = escape(&vm.preset_stdin), - ), - LinkMode::Static { .. } => { - if vm.preset_stdin.is_empty() { - String::new() - } else { - format!( - r#"

      Demo stdin from frontmatter (static export cannot re-run interactively):

      -
      {stdin}
      "#, + path = escape(rel), + hint = hint, + rows = rows, + placeholder = escape(&placeholder), stdin = escape(&vm.preset_stdin), ) } + LinkMode::Static { .. } => { + if vm.preset_stdin.is_empty() { + String::new() + } else { + format!( + r#"

      Demo stdin (static export cannot re-run interactively); prompts: {prompts}

      +
      {stdin}
      "#, + prompts = escape(&vm.input_prompts.join(" · ")), + stdin = escape(&vm.preset_stdin), + ) + } + } } }; let title = Path::new(rel) @@ -648,6 +777,18 @@ pub fn page_file(files: &[PathBuf], rel: &str, vm: &FileViewModel, links: &LinkM .and_then(|s| s.to_str()) .unwrap_or(rel) .trim_end_matches(".mq.md"); + let plots_html = if vm.plots.is_empty() { + String::new() + } else { + let mut s = String::from(r#"
      "#); + for svg in &vm.plots { + s.push_str(r#"
      "#); + s.push_str(svg); + s.push_str("
      "); + } + s.push_str("
      "); + s + }; let main = format!( r#"

      {title}{status_label}

      @@ -660,6 +801,7 @@ pub fn page_file(files: &[PathBuf], rel: &str, vm: &FileViewModel, links: &LinkM

      Execution

      {stdin_panel}
      {out}
      + {plots}

      Source

      @@ -673,6 +815,7 @@ pub fn page_file(files: &[PathBuf], rel: &str, vm: &FileViewModel, links: &LinkM structure = vm.structure_html, stdin_panel = stdin_panel, out = out_text, + plots = plots_html, source = escape(&vm.source), ); layout(rel, &nav, &main) diff --git a/src/view/mod.rs b/src/view/mod.rs index 7e99330..0cca946 100644 --- a/src/view/mod.rs +++ b/src/view/mod.rs @@ -16,7 +16,7 @@ use tiny_http::{Header, Method, Request, Response, Server, StatusCode}; use crate::input_feed::{effective_stdin, split_stdin_text}; use crate::view::html::{escape, page_file, page_index, LinkMode}; -use crate::view::render::{render_module_structure, FileViewModel}; +use crate::view::render::{collect_input_prompts, render_module_structure, FileViewModel}; use crate::{run_file_capture, RunOptions}; pub struct ViewOptions { @@ -167,11 +167,18 @@ pub(crate) fn build_file_view( live: bool, ) -> Result { let source = fs::read_to_string(abs).with_context(|| format!("read {}", abs.display()))?; - let structure = match crate::load::load_module(abs) { - Ok(module) => render_module_structure(&module, &source), - Err(e) => format!( - "
      parse/load error: {}
      ", - escape(&tidy_user_error(&format!("{e:#}"), abs, rel)) + // Structure shows this file only — do not merge imported lib bodies into the tree. + let (structure, input_prompts) = match crate::parse::parse_source(&source) { + Ok(module) => ( + render_module_structure(&module, &source), + collect_input_prompts(&module), + ), + Err(e) => ( + format!( + "
      parse/load error: {}
      ", + escape(&tidy_user_error(&format!("{e:#}"), abs, rel)) + ), + Vec::new(), ), }; let effective = effective_stdin(&source, stdin_lines); @@ -181,12 +188,18 @@ pub(crate) fn build_file_view( opts.sleep_limit_ms = if live { Some(30_000) } else { Some(0) }; // Optional: sandbox to the whole view tree so sibling folders are reachable. opts.fs_root = Some(root.root.clone()); - let (stdout, stderr, ok) = match run_file_capture(abs, &opts) { - Ok(cap) => (cap.stdout, String::new(), true), + let (stdout, stderr, ok, plots) = match run_file_capture(abs, &opts) { + Ok(cap) => ( + cap.stdout, + String::new(), + true, + cap.plots.into_iter().map(|p| p.svg).collect(), + ), Err(e) => ( String::new(), tidy_user_error(&format!("{e:#}"), abs, rel), false, + Vec::new(), ), }; Ok(FileViewModel { @@ -197,6 +210,8 @@ pub(crate) fn build_file_view( stderr, ok, preset_stdin: effective.join("\n"), + input_prompts, + plots, }) } diff --git a/src/view/output.rs b/src/view/output.rs index 2e41452..0edcc78 100644 --- a/src/view/output.rs +++ b/src/view/output.rs @@ -30,6 +30,7 @@ pub fn write_static(opts: OutputOptions) -> Result<()> { vm.stdout.clear(); vm.stderr = "execution skipped (--no-exec)".into(); vm.ok = true; + vm.plots.clear(); } let links = LinkMode::Static { from: Some(rel.clone()), diff --git a/src/view/render.rs b/src/view/render.rs index 1ee8112..804ff68 100644 --- a/src/view/render.rs +++ b/src/view/render.rs @@ -20,6 +20,123 @@ pub struct FileViewModel { pub ok: bool, /// Text shown in the live-view preset stdin box. pub preset_stdin: String, + /// One entry per `input` / `输入` call (prompt text; may be empty). + /// Empty vec → page does not use input; hide the preset form. + pub input_prompts: Vec, + /// SVG plots from math lib (embedded in Execution). + pub plots: Vec, +} + +/// Collect prompt strings from every `input` / `输入` call in the module (pre-order). +pub fn collect_input_prompts(module: &Module) -> Vec { + let mut out = Vec::new(); + for fun in &module.functions { + collect_input_prompts_fun(fun, &mut out); + } + out +} + +fn collect_input_prompts_fun(fun: &Function, out: &mut Vec) { + for stmt in &fun.body { + collect_input_prompts_stmt(stmt, out); + } + for child in &fun.children { + collect_input_prompts_fun(child, out); + } +} + +fn collect_input_prompts_stmt(stmt: &Stmt, out: &mut Vec) { + match stmt { + Stmt::Assign { value, .. } | Stmt::Return { value, .. } => { + collect_input_prompts_expr(value, out); + } + Stmt::Call { call, .. } => { + push_input_prompt(call, out); + for a in &call.args { + match a { + Arg::Positional(e) | Arg::Named { value: e, .. } => { + collect_input_prompts_expr(e, out); + } + } + } + } + Stmt::Branch { arms, .. } => { + for arm in arms { + if let Some(c) = &arm.condition { + collect_input_prompts_expr(c, out); + } + for s in &arm.body { + collect_input_prompts_stmt(s, out); + } + } + } + Stmt::While { + condition, body, .. + } => { + collect_input_prompts_expr(condition, out); + for s in body { + collect_input_prompts_stmt(s, out); + } + } + Stmt::ForEach { body, .. } => { + for s in body { + collect_input_prompts_stmt(s, out); + } + } + } +} + +fn collect_input_prompts_expr(expr: &Expr, out: &mut Vec) { + match expr { + Expr::Call(call) => { + push_input_prompt(call, out); + for a in &call.args { + match a { + Arg::Positional(e) | Arg::Named { value: e, .. } => { + collect_input_prompts_expr(e, out); + } + } + } + } + Expr::Unary { expr, .. } => collect_input_prompts_expr(expr, out), + Expr::Binary { left, right, .. } => { + collect_input_prompts_expr(left, out); + collect_input_prompts_expr(right, out); + } + Expr::List(items) => { + for e in items { + collect_input_prompts_expr(e, out); + } + } + Expr::Literal(_) | Expr::Var(_) | Expr::Interp(_) | Expr::Formula(_) => {} + } +} + +fn push_input_prompt(call: &CallExpr, out: &mut Vec) { + if crate::aliases::canonical_builtin(&call.callee) != Some("input") { + return; + } + for a in &call.args { + if let Arg::Named { name, value } = a { + if crate::aliases::canonical_param("input", name) == "prompt" { + out.push(prompt_expr_text(value)); + return; + } + } + } + if let Some(Arg::Positional(value)) = call.args.first() { + out.push(prompt_expr_text(value)); + return; + } + out.push(String::new()); +} + +fn prompt_expr_text(expr: &Expr) -> String { + match expr { + Expr::Literal(Literal::Text(t)) => t.clone(), + Expr::Literal(lit) => lit_display(lit), + other => expr_display(other), + } } pub fn render_module_structure(module: &Module, source: &str) -> String { @@ -209,9 +326,8 @@ fn stmt_start(stmt: &Stmt) -> u32 { fn stmt_end_line(stmt: &Stmt) -> u32 { match stmt { - Stmt::Assign { span, .. } | Stmt::Return { span, .. } | Stmt::Call { span, .. } => { - span.line + 1 - } + Stmt::Assign { end_line, .. } => end_line + 1, + Stmt::Return { span, .. } | Stmt::Call { span, .. } => span.line + 1, Stmt::Branch { arms, span, .. } => { let mut end = span.line + 1; for arm in arms { @@ -234,11 +350,25 @@ fn stmt_end_line(stmt: &Stmt) -> u32 { fn render_stmt(stmt: &Stmt, lines: &[ClassifiedLine]) -> (String, u32) { let end = stmt_end_line(stmt); let html = match stmt { - Stmt::Assign { name, value, .. } => format!( - "
      bind`{}` = {}
      ", - escape(name), - escape(&expr_display(value)) - ), + Stmt::Assign { + name, + value: Expr::Formula(e), + .. + } => { + let tex = escape(&formula_ascii_to_tex(&e.as_display())); + format!( + "
      formula \ + `{}` = \ +
      $${}$$
      ", + escape(name), + tex + ) + } + Stmt::Assign { name, value, .. } => format!( + "
      bind `{}` = {}
      ", + escape(name), + escape(&expr_display(value)) + ), Stmt::Return { value, .. } => format!( "
      return{}
      ", escape(&expr_display(value)) @@ -388,9 +518,67 @@ fn expr_prec(expr: &Expr, parent_prec: u8) -> String { let parts: Vec = items.iter().map(|e| expr_prec(e, 0)).collect(); format!("[{}]", parts.join(", ")) } + Expr::Formula(e) => format!("$$ {} $$", e.as_display()), } } +/// Best-effort ASCII formula → TeX for KaTeX in view Structure. +fn formula_ascii_to_tex(ascii: &str) -> String { + let mut out = String::new(); + let chars: Vec = ascii.chars().collect(); + let mut i = 0usize; + while i < chars.len() { + let c = chars[i]; + if c == '*' { + // multiplication: a*b → a \cdot b + out.push_str(r" \cdot "); + i += 1; + continue; + } + if c == '^' { + out.push('^'); + i += 1; + if i < chars.len() && chars[i] == '(' { + out.push('{'); + i += 1; + let start = i; + let mut depth = 1i32; + while i < chars.len() && depth > 0 { + match chars[i] { + '(' => depth += 1, + ')' => depth -= 1, + _ => {} + } + if depth > 0 { + i += 1; + } + } + out.push_str(&chars[start..i].iter().collect::()); + if i < chars.len() && chars[i] == ')' { + i += 1; + } + out.push('}'); + } else if i < chars.len() { + out.push('{'); + out.push(chars[i]); + out.push('}'); + i += 1; + } + continue; + } + // TeX specials that may appear in identifiers rarely + match c { + '{' | '}' | '%' | '&' | '#' | '$' => { + out.push('\\'); + out.push(c); + } + _ => out.push(c), + } + i += 1; + } + out +} + fn wrap(inner: String, prec: u8, parent_prec: u8) -> String { if prec < parent_prec { format!("({inner})") @@ -476,4 +664,53 @@ mod tests { assert!(html.contains("code"), "{html}"); assert!(!html.contains("[仓库](https://github.com/cflmy/marqdo)")); } + + #[test] + fn collect_input_prompts_from_fixture() { + let src = include_str!("../../tests/keywords/input.mq.md"); + let module = crate::parse::parse_source(src).unwrap(); + let prompts = collect_input_prompts(&module); + assert_eq!(prompts, vec!["Name:".to_string()]); + } + + #[test] + fn collect_input_prompts_absent_without_input() { + let src = include_str!("../../tests/structure/hello.mq.md"); + let module = crate::parse::parse_source(src).unwrap(); + assert!(collect_input_prompts(&module).is_empty()); + } + + #[test] + fn structure_omits_imported_lib_bodies() { + let src = "---\ntitle: t\n> lib/text.mq.md\n---\n\n# main\n\n> print text=hi\n"; + let local = crate::parse::parse_source(src).unwrap(); + let html = render_module_structure(&local, src); + assert!(html.contains("badge\">import"), "{html}"); + assert!(html.contains("lib/text.mq.md"), "{html}"); + assert!(html.contains("main"), "{html}"); + assert!(!html.contains("trim"), "{html}"); + assert_eq!(local.functions.len(), 1); + assert_eq!(local.functions[0].name, "main"); + } + + #[test] + fn structure_formula_assign_not_comment() { + let src = include_str!("../../tests/lib/math-formula.mq.md"); + let module = crate::parse::parse_source(src).unwrap(); + let html = render_module_structure(&module, src); + assert!(html.contains("badge\">formula"), "{html}"); + assert!(html.contains("math-block"), "{html}"); + assert!(html.contains("$$"), "{html}"); + assert!( + !html.contains("comment-text\">x^2 - 2") + && !html.contains("comment-text\">

      x^2 - 2"), + "formula fence leaked into comments: {html}" + ); + } + + #[test] + fn formula_ascii_to_tex_pow_and_mul() { + assert_eq!(formula_ascii_to_tex("x^2 - 2"), "x^{2} - 2"); + assert_eq!(formula_ascii_to_tex("2*x"), r"2 \cdot x"); + } } diff --git a/tests/gold.rs b/tests/gold.rs index 06deaeb..fab0d67 100644 --- a/tests/gold.rs +++ b/tests/gold.rs @@ -543,6 +543,12 @@ fn view_output_writes_html() { assert!(index.contains("#ffffff") || index.contains("--surface: #ffffff")); assert!(index.contains("nav-toggle")); assert!(!index.contains("Run with input"), "static export should omit live stdin form"); + let page = std::fs::read_to_string(dir.join("pages").join("hello.mq.md.html")).unwrap(); + assert!(page.contains("katex.min.css"), "view layout should load KaTeX"); + assert!( + !page.contains("name=\"stdin\""), + "hello has no input; no preset form" + ); assert!(dir.join("pages").join("hello.mq.md.html").exists()); } @@ -579,6 +585,57 @@ fn lib_net_encode() { assert_out("tests/lib/net-encode.mq.md", "a+b"); } +#[test] +fn lib_math_formula() { + assert_out( + "tests/lib/math-formula.mq.md", + "formula\n2*x\n[-1.4142135624, 1.4142135624]\n7", + ); +} + +#[test] +fn lib_math_formula_chain() { + assert_out( + "tests/lib/math-formula-chain.mq.md", + "formula\n3*2*x\n12", + ); +} + +#[test] +fn lib_math_random() { + assert_out("tests/lib/math-random.mq.md", "4\n7\n4"); +} + +#[test] +fn lib_math_zh_num() { + assert_out("tests/lib/数学-数值.mq.md", "num\n0"); +} + +#[test] +fn lib_math_plot() { + let path = "tests/lib/math-plot.mq.md"; + let (code, stdout, stderr) = run(&["run", path]); + assert_eq!(code, 0, "{path} stderr={stderr}"); + assert!( + stdout.lines().next() == Some("text"), + "{path} stdout={stdout}" + ); + assert!( + stdout.contains("plot:"), + "{path} missing plot: line in {stdout}" + ); + let _ = std::fs::remove_file("tests/lib/math-plot-plot-1.svg"); +} + +#[test] +fn bytecode_lib_math_formula() { + assert_out_backend( + "tests/lib/math-formula.mq.md", + "bytecode", + "formula\n2*x\n[-1.4142135624, 1.4142135624]\n7", + ); +} + #[test] fn bytecode_lib_json() { assert_out_backend( diff --git a/tests/lib/math-formula-chain.mq.md b/tests/lib/math-formula-chain.mq.md new file mode 100644 index 0000000..0bb491c --- /dev/null +++ b/tests/lib/math-formula-chain.mq.md @@ -0,0 +1,25 @@ +--- +title: math formula chain +> lib/math.mq.md +--- + +# main + +`f` = +$$ +x^3 +$$ + +*`df` = > diff formula=`f` var=x * + +*`ty` = > type `df` * + +> print text=`ty` + +*`df2` = > diff formula=`df` var=x * + +> print text=`df2` + +*`y` = > eval formula=`df` var=x value=2 * + +> print text=`y` diff --git a/tests/lib/math-formula.mq.md b/tests/lib/math-formula.mq.md new file mode 100644 index 0000000..5f9ffb9 --- /dev/null +++ b/tests/lib/math-formula.mq.md @@ -0,0 +1,27 @@ +--- +title: math formula pipeline +> lib/math.mq.md +--- + +# main + +`f` = +$$ +x^2 - 2 +$$ + +*`ty` = > type `f` * + +> print text=`ty` + +*`df` = > diff formula=`f` var=x * + +> print text=`df` + +*`roots` = > solve formula=`f` var=x * + +> print text=`roots` + +*`y` = > eval formula=`f` var=x value=3 * + +> print text=`y` diff --git a/tests/lib/math-plot.mq.md b/tests/lib/math-plot.mq.md new file mode 100644 index 0000000..649db02 --- /dev/null +++ b/tests/lib/math-plot.mq.md @@ -0,0 +1,17 @@ +--- +title: math plot svg +> lib/math.mq.md +--- + +# main + +`f` = +$$ +x^2 +$$ + +*`svg` = > plot formula=`f` var=x min=-2 max=2 * + +*`ok` = > type `svg` * + +> print text=`ok` diff --git a/tests/lib/math-random.mq.md b/tests/lib/math-random.mq.md new file mode 100644 index 0000000..6c2917e --- /dev/null +++ b/tests/lib/math-random.mq.md @@ -0,0 +1,22 @@ +--- +title: math random seed +> lib/math.mq.md +--- + +# main + +> seed value=42 + +*`a` = > random_int min=1 max=10 * + +*`b` = > random_int min=1 max=10 * + +> seed value=42 + +*`c` = > random_int min=1 max=10 * + +> print text=`a` + +> print text=`b` + +> print text=`c` diff --git a/tests/lib/数学-数值.mq.md b/tests/lib/数学-数值.mq.md new file mode 100644 index 0000000..df981ba --- /dev/null +++ b/tests/lib/数学-数值.mq.md @@ -0,0 +1,16 @@ +--- +title: math num + zh +> lib/数学.mq.md +--- + +# main + +*`p` = > 圆周率 * + +*`t` = > type `p` * + +> print text=`t` + +*`s` = > 正弦 value=0 * + +> print text=`s`