Si2C

Appearance

高等数学：极限、微分、积分 ​

概念 ​

上一篇（math/01-discrete.md）讲的是"可数对象"的数学——命题、集合、关系、图，全是一个一个数得出来的东西。

这一篇要讲它的反面：

微积分=研究连续变化的数学

一句话概括全篇的三个主角：

概念一句话符号
极限"无限靠近"这件事怎么用数学说清楚lim
导数"变化得多快"f'(x) = df/dx
积分"累积了多少"∫ f dx

它们的关系是一张图：

      求导（微分）          ∫
  f  ──────────────►  f'   f' ──────────► f
     ◄──────────────          ◄──────────
      + C（不定积分）

导数和积分互为逆运算——这就是"微积分基本定理"（牛顿-莱布尼茨公式）的全部内容。

为什么主线需要它：

主线的哪一处用到什么
arch 性能评价平均访存时间、加速比的"极限"分析（lim 的意义）
arch 浮点运算sqrt、exp、log 在硬件里怎么算（泰勒展开/迭代法）
ds 复杂度增长阶的比较本质是极限（O(f) 就是 lim n→∞ g/f 有界）
circuit/02-rc.mdt50 = 0.6931τ 里的 ln2 是积分算出来的
elec 信号与系统卷积、傅里叶变换都是积分；线性系统的微分方程
auto 自动控制系统的微分方程 + 特征根定稳定性
os 调度/排队平均等待时间 = 一个积分（概率分布的期望）

⚠️ 界限要说清楚：math 这门课"不做独立体系，按主线用到什么就补什么"。 所以本篇不是完整的高数教材——极限、微分、积分的"定义与常用结论"讲全，多重积分、级数的收敛判别、曲线曲面积分等只在需要时提一句。 写它的目的是：当你在 elec 或 auto 里遇到一个微分方程、在 arch 里遇到一个泰勒近似时，知道这些东西从哪来、怎么算。

本篇在主线上的位置：它与 math/01-discrete.md 是一对——离散热坐 L0/L1（硅与电路），连续数学坐 elec/auto（信号与控制）。 两篇合起来才是 math 这门工具箱的全貌。

原理 ​

一、极限：一切的地基 ​

定义（ε-δ 的直觉版）：lim_{x→a} f(x) = L 意思是"只要 x 足够靠近 a（但不等于 a），f(x) 就可以任意靠近 L"。

"任意靠近"用 ε 描述，ε 有多小都能满足；"足够靠近"用 δ 描述，δ 是你要付出的精度。 ε 是挑战，δ 是回应。

三条基本规矩：

规矩内容
① 左右极限都存在且相等，极限才存在lim_{x→a⁻}f = lim_{x→a⁺}f = L
② 极限的四则运算加减乘除都能拆（除数极限非 0）
③ 连续 = 极限值等于函数值lim_{x→a} f(x) = f(a)

两个"重要极限"（工程上出现频率极高）：

limx→0sin⁡xx=1limn→∞(1+1n)n=e=2.718281828…
  • 第一个：是"小角度近似 sin x ≈ x"的依据——elec 里的相位近似、arch 里的三角运算都用它；
  • 第二个：是"复利"的极限——e 的定义式。 os 里的 e^-1 ≈ 0.368（内存访问的指数分布）、队列论里的到达过程都来自它。

等价无穷小（x→0 时的替换表，做题加速器）：

原式等价无穷小替换后的量级
sin xx一阶
tan xx一阶
ln(1+x)x一阶
e^x − 1x一阶
1 − cos xx²/2二阶
(1+x)^α − 1αx一阶

⚠️ 替换有严格的适用边界：只适用于"整个式子是一个乘除因子"的场合。 lim (sin x − x)/x³ 里如果把 sin x 直接换成 x，会得到 0 而不是正确答案 −1/6——因为这里 sin x 与 x 相减，抵消后剩下的正是"高阶项"，而等价无穷小把高阶项扔掉了。 例 1 会把这个陷阱算出来给你看。

连续性与间断点：

类型特征
第一类·可去左右极限存在且相等，但不等于函数值（有个"洞"）
第一类·跳跃左右极限存在但不相等
第二类·无穷/振荡极限不存在（趋向 ∞ 或来回振荡）

极限这一节在主线里的落点：ds 的 O、Ω、Θ 记号全是极限——

g(n)=O(f(n))⟺limn→∞g(n)f(n)<∞

"n 足够大时，常数因子不重要"这句话，写出来就是一个极限。

二、导数：变化率 ​

定义式（务必能默写）：

f′(x)=limΔx→0f(x+Δx)−f(x)Δx

三个读法：

视角含义
几何曲线在该点的切线斜率
物理瞬时变化率（位置→速度→加速度，求导两次）
工程"输入变一点，输出变多少"——灵敏度、放大倍数

求导法则（把这张表当乘法口诀）：

类型公式
幂函数(x^n)' = n x^{n-1}
指数(e^x)' = e^x；(a^x)' = a^x ln a
对数(ln x)' = 1/x
正弦余弦(sin x)' = cos x；(cos x)' = −sin x
乘积(uv)' = u'v + uv'
商(u/v)' = (u'v − uv')/v²
链式（最重要）[f(g(x))]' = f'(g(x)) · g'(x)

链式法则是"复合"的求导方式——在工程里它有个更常见的名字："逐级相乘的增益"。arch 里一条数据通路的总延迟 = 各级延迟相加（不是相乘），而"放大倍数"（如运放级联）才是相乘——这两件事的区别就在链式法则和加法法则上。

极值与中值定理：

结论内容
极值必要条件（费马定理）可导极值点必有 f'(x) = 0（驻点）
一阶判别f' 由正变负 → 极大；由负变正 → 极小
二阶判别f'(x₀)=0 且 f''(x₀)<0 → 极大；>0 → 极小
罗尔定理f(a)=f(b) 且连续可导 → 中间有点 f'=0
拉格朗日中值定理中间有点 f'(ξ) = (f(b)−f(a))/(b−a)——"平均变化率必在某点被瞬时变化率取到"

洛必达法则（求 0/0 或 ∞/∞ 型极限）：

limx→af(x)g(x)=limx→af′(x)g′(x)（要求右边极限存在，且原式为不定式）

⚠️ 两个前提：① 必须是 0/0 或 ∞/∞；② 右边的极限要存在。 不满足就硬套，会得出错的结论。

三、积分：累积 ​

不定积分 = 求原函数：

∫f(x)dx=F(x)+C(F′(x)=f(x))

+C 是关键：原函数有无穷多个，彼此差一个常数。 这对应工程上的"初始条件"——circuit/02-rc.md 里电容电压的积分常数，就是"t=0 时电容上有没有电"。

基本积分表（与求导表反向）：

被积函数原函数
x^n（n ≠ −1）x^{n+1}/(n+1)
1/xln∣x∣
e^xe^x
sin x−cos x
cos xsin x
1/(1+x²)arctan x

定积分 = 黎曼和的极限：

∫abf(x)dx=limn→∞∑i=1nf(xi)Δx(Δx=b−an)

牛顿-莱布尼茨公式（把"求和的极限"变成"两步减法"）：

∫abf(x)dx=F(b)−F(a)

两个常用的积分方法：

方法形式什么时候用
换元法∫ f(g(x))g'(x)dx = ∫ f(u)du被积式里"藏着某个函数的导数"
分部积分∫ u\,dv = uv − ∫ v\,du多项式 × 指数/三角/对数

积分的三个工程读法：

读法公式例子
面积∫_a^b f 是曲线下的面积circuit 里电荷 = 电流对时间的积分
累积量"变化率 × 时间"的连续版s = ∫v dt
平均值\bar f = \frac{1}{b-a}\int_a^b fos 里的平均等待时间、elec 里的有效值

"平均值 = 积分 ÷ 区间长度"这一条，是主线里出现最多的积分用法：性能评价里的"平均访存时间"就是各挡时间的加权和（离散版积分）；一个正弦量的平均值是 0，但它的有效值是 1/√2 ≈ 0.7071 倍幅值——那就得靠平方后再积分。 例 3 会把它算出来。

四、泰勒展开与近似：工程上最值钱的一节 ​

泰勒公式：

f(x)=∑k=0nf(k)(x0)k!(x−x0)k+Rn(x)

x₀ = 0 时叫麦克劳林展开。五个必背的展开：

函数展开
e^x1 + x + x²/2! + x³/3! + ⋯ （收敛半径 ∞）
sin xx − x³/3! + x⁵/5! − ⋯ （只有奇次项）
cos x1 − x²/2! + x⁴/4! − ⋯ （只有偶次项）
ln(1+x)x − x²/2 + x³/3 − ⋯ （∣x∣ < 1）
1/(1−x)1 + x + x² + x³ + ⋯ （∣x∣ < 1，等比级数）

为什么这节最重要——因为硬件里没有"求 sin"这条指令：

场景用到的近似
sin x 的硬件实现取前 3~4 项，配合区间压缩（把 x 归到小范围）
1/(1+x) 的快速倒数只用一阶项 1 − x，或牛顿迭代
sqrt 的硬件实现牛顿迭代（每一步误差平方级下降）
arch 里"定点/浮点乘除要几个周期"本质是"要几项泰勒"
auto 里非线性系统线性化一阶泰勒 = 在工作点求导

一阶近似（线性化）的写法：

f(x0+Δx)≈f(x0)+f′(x0)Δx

这就是"小信号模型"——circuit/03-analog.md 里推 g_m = 2I_D/V_ov，auto 里在平衡点附近线性化，用的都是这一条。

误差项：R_n(x) = f^{(n+1)}(ξ)/(n+1)! · (x−x₀)^{n+1}——"截断误差的量级由下一项决定"，所以"取到第几项"和"x 有多小"必须一起考虑。

五、微分方程入门：给 elec 与 auto 铺路 ​

微分方程 = 含导数的方程。 主线里最著名的一个就在 circuit：

一阶 RC 充电电路的运动方程（回链 circuit/02-rc.md）：

RCdVCdt+VC=VS⟹VC(t)=VS(1−e−t/RC)

怎么解出来（分离变量）：

步操作
1整理成 dV_C/dt = (V_S − V_C)/RC
2分离：dV_C/(V_S − V_C) = dt/RC
3两边积分：−ln(V_S − V_C) = t/RC + C₁
4代初始条件 V_C(0) = 0 定 C₁
5得 V_C = V_S(1 − e^{−t/RC})

由此直接得到 circuit/02-rc.md 用过的两个数：

t50=RCln⁡2≈0.6931τtr (10%→90%)=τln⁡9≈2.1972τ

这两个数是"积分解出来的"，不是查表来的——ln 2 与 ln 9 就是那条解里解出来的指数。

二阶常系数齐次方程（auto 的控制系统、elec 的 RLC 都用）：

ay″+by′+cy=0⟹aλ2+bλ+c=0（特征方程）
判别式两个特征根解的形状物理行为
b² − 4ac > 0两个不等实根C₁e^{λ₁t} + C₂e^{λ₂t}过阻尼，无振荡
= 0重根 λ(C₁ + C₂t)e^{λt}临界阻尼
< 0共轭复根 α ± jβe^{αt}(C₁cos βt + C₂sin βt)欠阻尼，振荡

稳定性判据（一句话）：

特征根的实部全为负⟺解随时间衰减⟺系统稳定

auto 里"极点在左半平面"的说法，根就在这里。 elec 里拉普拉斯变换把微分方程变成代数方程（见 math/21-complex.md），是同一件事的"频域版本"。

⚠️ 解不出来的时候怎么办：数值解。 最朴素的是欧拉法：

yk+1=yk+hf(tk,yk)

h 是步长。 欧拉法是一阶精度（误差 O(h)）——"步长减半、误差减半"。例 5 会用它算 RC 电路，与解析解逐点对账，并展示"步长不够时误差长什么样"。

六、微积分在主线的六个落点 ​

落点微积分在做什么
circuit/02-rc.md微分方程 → 指数响应；t50 = τ ln2
arch 浮点/性能泰勒展开做算术；极限做"理想加速比"分析
ds 复杂度O/Ω/Θ 都是极限
os 调度与排队平均等待时间 = 积分（期望）
elec 信号与系统卷积、傅里叶变换都是积分
auto 自动控制微分方程 + 特征根定稳定性

示例 ​

例 1：极限的数值观察与"精度陷阱" ​

任务：把两个重要极限"看"出来，并验证等价无穷小的替换边界。

python
import math, unicodedata

def w(s):
    return sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in s)

def pad(s, n):
    return s + " " * max(0, n - w(s))

print("=== ① lim sin(x)/x → 1（x → 0） ===")
print("  " + pad("x", 12) + pad("sin(x)/x", 22) + "与 1 的差")
for k in range(1, 9):
    x = 10.0 ** (-k)
    v = math.sin(x) / x
    print("  " + pad("1e-%d" % k, 12) + pad("%.15f" % v, 22) + "%+.3e" % (v - 1))
print("  ★ x 小到 1e-8 时结果就成了精确的 1.0 —— 这不是「真的等于 1」，")
print("    而是 sin(x) 与 x 在双精度下已经分不出来了（差值约 x^3/6 = 1.7e-25，远低于 eps = 2.2e-16）")

print()
print("=== ② lim (1 + 1/n)^n → e（n → ∞） ===")
print("  " + pad("n", 14) + pad("(1+1/n)^n", 22) + "与 e 的差")
for n in (10, 100, 1000, 10 ** 4, 10 ** 6, 10 ** 8):
    v = (1 + 1.0 / n) ** n
    print("  " + pad("%d" % n, 14) + pad("%.15f" % v, 22) + "%+.3e" % (v - math.e))
print("  e = %.15f" % math.e)
print("  ★ 差先是 O(1/n) 地缩小，到 n = 1e8 反而变差 —— 因为 1 + 1e-8 已经丢有效位")

print()
print("=== ③ 等价无穷小的替换精度（x = 0.001） ===")
x = 0.001
ROWS = [
    ("sin x", math.sin(x), x),
    ("tan x", math.tan(x), x),
    ("ln(1+x)", math.log1p(x), x),
    ("e^x - 1", math.exp(x) - 1, x),
    ("1 - cos x", 1 - math.cos(x), x * x / 2),
]
print("  " + pad("原式", 12) + pad("真值", 20) + pad("等价替换值", 20) + "相对误差")
for name, real, approx in ROWS:
    print("  " + pad(name, 12) + pad("%.12f" % real, 20) + pad("%.12f" % approx, 20)
          + "%.3e" % abs((real - approx) / real))

print()
print("=== ④ 陷阱：lim (sin x - x) / x^3，替换会算错 ===")
print("  " + pad("x", 12) + pad("(sin x - x)/x^3", 22) + "与 -1/6 的差")
for k in (1, 2, 3, 4):
    xx = 10.0 ** (-k)
    v = (math.sin(xx) - xx) / xx ** 3
    print("  " + pad("1e-%d" % k, 12) + pad("%.15f" % v, 22) + "%+.3e" % (v + 1 / 6))
print("  -1/6 = %.15f" % (-1 / 6))
print("  ★ 若把 sin x 直接替换成 x，分子变成 0，答案会算成 0；")
print("    真相是 sin x - x ≈ -x^3/6，剩下的正是「被等价无穷小丢掉的高阶项」")

预期输出：

=== ① lim sin(x)/x → 1（x → 0） ===
  x           sin(x)/x              与 1 的差
  1e-1        0.998334166468282     -1.666e-03
  1e-2        0.999983333416666     -1.667e-05
  1e-3        0.999999833333342     -1.667e-07
  1e-4        0.999999998333333     -1.667e-09
  1e-5        0.999999999983333     -1.667e-11
  1e-6        0.999999999999833     -1.666e-13
  1e-7        0.999999999999998     -1.665e-15
  1e-8        1.000000000000000     +0.000e+00
  ★ x 小到 1e-8 时结果就成了精确的 1.0 —— 这不是「真的等于 1」，
    而是 sin(x) 与 x 在双精度下已经分不出来了（差值约 x^3/6 = 1.7e-25，远低于 eps = 2.2e-16）

=== ② lim (1 + 1/n)^n → e（n → ∞） ===
  n             (1+1/n)^n             与 e 的差
  10            2.593742460100002     -1.245e-01
  100           2.704813829421528     -1.347e-02
  1000          2.716923932235594     -1.358e-03
  10000         2.718145926824926     -1.359e-04
  1000000       2.718280469095753     -1.359e-06
  100000000     2.718281798347358     -3.011e-08
  e = 2.718281828459045
  ★ 差先是 O(1/n) 地缩小，到 n = 1e8 反而变差 —— 因为 1 + 1e-8 已经丢有效位

=== ③ 等价无穷小的替换精度（x = 0.001） ===
  原式        真值                等价替换值          相对误差
  sin x       0.000999999833      0.001000000000      1.667e-07
  tan x       0.001000000333      0.001000000000      3.333e-07
  ln(1+x)     0.000999500333      0.001000000000      4.999e-04
  e^x - 1     0.001000500167      0.001000000000      4.999e-04
  1 - cos x   0.000000500000      0.000000500000      8.335e-08

=== ④ 陷阱：lim (sin x - x) / x^3，替换会算错 ===
  x           (sin x - x)/x^3       与 -1/6 的差
  1e-1        -0.166583353171851    +8.331e-05
  1e-2        -0.166665833335744    +8.333e-07
  1e-3        -0.166666658339004    +8.328e-09
  1e-4        -0.166666661483190    +5.183e-09
  -1/6 = -0.166666666666667
  ★ 若把 sin x 直接替换成 x，分子变成 0，答案会算成 0；
    真相是 sin x - x ≈ -x^3/6，剩下的正是「被等价无穷小丢掉的高阶项」

例 2：导数的解析解与数值差分对账 ​

任务：用三种方式求 f(x) = x² sin x 在 x = 1 处的导数，并扫描步长找出数值求导的"最优 h"。

python
import math, unicodedata

def w(s):
    return sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in s)

def pad(s, n):
    return s + " " * max(0, n - w(s))

f = lambda x: x * x * math.sin(x)
df = lambda x: 2 * x * math.sin(x) + x * x * math.cos(x)     # 乘积法则

print("=== ① 解析求导（乘积法则） ===")
print("  f(x)  = x^2 · sin x")
print("  f'(x) = 2x · sin x + x^2 · cos x")
print("  在 x = 1：2×1×sin(1) + 1×cos(1) = %.15f + %.15f" % (2 * math.sin(1), math.cos(1)))
print("  解析结果 f'(1) = %.15f" % df(1))
print("  （sin(1) = %.15f，cos(1) = %.15f，角度单位是弧度）" % (math.sin(1), math.cos(1)))

print()
print("=== ② 中心差分与步长扫描 ===")
print("  公式：f'(x) ≈ [f(x+h) − f(x−h)] / (2h)，截断误差 O(h^2)")
print("  " + pad("h", 12) + pad("数值导数", 22) + pad("绝对误差", 14) + "误差/前一行")
exact = df(1.0)
prev = None
for k in range(1, 12):
    h = 10.0 ** (-k)
    num = (f(1.0 + h) - f(1.0 - h)) / (2 * h)
    err = abs(num - exact)
    ratio = "—" if prev is None else "%.3f" % (err / prev)
    print("  " + pad("1e-%d" % k, 12) + pad("%.15f" % num, 22) + pad("%.3e" % err, 14) + ratio)
    prev = err

print()
print("=== ③ 前向差分 vs 中心差分（精度阶对比） ===")
print("  前向差分 f'(x) ≈ [f(x+h) − f(x)] / h，截断误差 O(h)")
print("  " + pad("h", 10) + pad("前向误差", 14) + pad("中心误差", 14) + "前向/中心")
for k in (2, 3, 4, 5):
    h = 10.0 ** (-k)
    fw = (f(1.0 + h) - f(1.0)) / h
    ce = (f(1.0 + h) - f(1.0 - h)) / (2 * h)
    ef, ec = abs(fw - exact), abs(ce - exact)
    print("  " + pad("1e-%d" % k, 10) + pad("%.3e" % ef, 14) + pad("%.3e" % ec, 14)
          + "%.1f 倍" % (ef / ec))
print("  ★ 同表可见：中心差分的误差 ≈ 前向误差 × h（比值 383 → 390770，随 h 缩小而放大）")
print("    这正是「截断误差 O(h^2) 对 O(h)」——阶数差 1，比值就差一个 1/h")
print("  ★ 同时看第二张表：h 小于 1e-5 后误差不降反升 —— 舍入误差开始占主导")
print("    所以数值求导的步长不是越小越好，本例最优 h = 1e-5（误差 3.8e-11）")

预期输出：

=== ① 解析求导（乘积法则） ===
  f(x)  = x^2 · sin x
  f'(x) = 2x · sin x + x^2 · cos x
  在 x = 1：2×1×sin(1) + 1×cos(1) = 1.682941969615793 + 0.540302305868140
  解析结果 f'(1) = 2.223244275483933
  （sin(1) = 0.841470984807897，cos(1) = 0.540302305868140，角度单位是弧度）

=== ② 中心差分与步长扫描 ===
  公式：f'(x) ≈ [f(x+h) − f(x−h)] / (2h)，截断误差 O(h^2)
  h           数值导数              绝对误差      误差/前一行
  1e-1        2.219330544380377     3.914e-03     —
  1e-2        2.223205153423358     3.912e-05     0.010
  1e-3        2.223243884264647     3.912e-07     0.010
  1e-4        2.223244271571390     3.913e-09     0.010
  1e-5        2.223244275445513     3.842e-11     0.010
  1e-6        2.223244275512126     2.819e-11     0.734
  1e-7        2.223244275345593     1.383e-10     4.907
  1e-8        2.223244272014924     3.469e-09     25.076
  1e-9        2.223244310872730     3.539e-08     10.201
  1e-10       2.223243811272368     4.642e-07     13.117
  1e-11       2.223243811272368     4.642e-07     1.000

=== ③ 前向差分 vs 中心差分（精度阶对比） ===
  前向差分 f'(x) ≈ [f(x+h) − f(x)] / h，截断误差 O(h)
  h         前向误差      中心误差      前向/中心
  1e-2      1.497e-02     3.912e-05     382.7 倍
  1e-3      1.501e-03     3.912e-07     3836.6 倍
  1e-4      1.501e-04     3.913e-09     38371.5 倍
  1e-5      1.501e-05     3.842e-11     390770.4 倍
  ★ 同表可见：中心差分的误差 ≈ 前向误差 × h（比值 383 → 390770，随 h 缩小而放大）
    这正是「截断误差 O(h^2) 对 O(h)」——阶数差 1，比值就差一个 1/h
  ★ 同时看第二张表：h 小于 1e-5 后误差不降反升 —— 舍入误差开始占主导
    所以数值求导的步长不是越小越好，本例最优 h = 1e-5（误差 3.8e-11）

例 3：定积分的三种数值算法与"平均值" ​

任务：算 ∫_0^1 x² dx（精确值 1/3）与 ∫_0^1 4/(1+x²) dx（精确值 π），对比三种算法的误差阶；再算正弦量的平均值与有效值。

python
import math, unicodedata

def w(s):
    return sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in s)

def pad(s, n):
    return s + " " * max(0, n - w(s))

def riemann(fn, a, b, n):          # 左端点矩形
    h = (b - a) / n
    return h * sum(fn(a + i * h) for i in range(n))

def trapezoid(fn, a, b, n):        # 梯形法
    h = (b - a) / n
    s = 0.5 * (fn(a) + fn(b))
    for i in range(1, n):
        s += fn(a + i * h)
    return h * s

def simpson(fn, a, b, n):          # 辛普森法，n 必须为偶数
    h = (b - a) / n
    s = fn(a) + fn(b)
    for i in range(1, n):
        s += (4 if i % 2 == 1 else 2) * fn(a + i * h)
    return h * s / 3

print("=== ① ∫_0^1 x^2 dx，精确值 = 1/3 ===")
f2 = lambda x: x * x
EXACT = 1 / 3
print("  精确值 1/3 = %.15f" % EXACT)
print("  " + pad("n", 8) + pad("黎曼和", 18) + pad("梯形法", 18) + pad("辛普森法", 18) + "辛普森误差")
for n in (10, 100, 1000):
    r, t, s = riemann(f2, 0, 1, n), trapezoid(f2, 0, 1, n), simpson(f2, 0, 1, n)
    print("  " + pad("%d" % n, 8) + pad("%.15f" % r, 18) + pad("%.15f" % t, 18)
          + pad("%.15f" % s, 18) + "%.3e" % abs(s - EXACT))
print()
print("  n 增大到 10 倍时的误差变化：")
for name, fn in (("黎曼和", riemann), ("梯形法", trapezoid), ("辛普森法", simpson)):
    e1 = abs(fn(f2, 0, 1, 10) - EXACT)
    e2 = abs(fn(f2, 0, 1, 100) - EXACT)
    e3 = abs(fn(f2, 0, 1, 1000) - EXACT)
    print("  " + pad(name, 10) + "%.3e → %.3e → %.3e   缩减比 %.1f / %.1f"
          % (e1, e2, e3, e1 / e2, e2 / e3))
print("  ★ 缩减比就告诉我们阶数：黎曼和 ≈ 10 倍（误差 ∝ h，即 O(h)）；")
print("    梯形法 ≈ 100 倍（误差 ∝ h^2，即 O(h^2)）；辛普森法对 x^2 已精确到机器精度，看不出阶")
print("    —— 是因为辛普森法对次数 ≤ 3 的多项式「精确成立」，不是近似")

print()
print("=== ② 用积分估 π：∫_0^1 4/(1+x^2) dx = π ===")
g = lambda x: 4 / (1 + x * x)
print("  " + pad("n", 8) + pad("辛普森近似", 18) + pad("与 π 的差", 14) + "有效位数")
for n in (4, 8, 16, 64):
    v = simpson(g, 0, 1, n)
    d = abs(v - math.pi)
    print("  " + pad("%d" % n, 8) + pad("%.15f" % v, 18) + pad("%.3e" % d, 14)
          + "%.1f 位" % (-math.log10(d) if d > 0 else 15))
print("  π = %.15f" % math.pi)

print()
print("=== ③ 平均值与有效值（正弦量的两个积分） ===")
SIN = lambda t: math.sin(t)
SIN2 = lambda t: math.sin(t) ** 2
mean_sin = (1 / (2 * math.pi)) * trapezoid(SIN, 0, 2 * math.pi, 2000)
mean_sin2 = (1 / (2 * math.pi)) * trapezoid(SIN2, 0, 2 * math.pi, 2000)
rms = math.sqrt(mean_sin2)
print("  平均值 = (1/2π)∫_0^2π sin t dt = %.15f（精确值 0，正负半周抵消）" % mean_sin)
print("  均方值 = (1/2π)∫_0^2π sin^2 t dt = %.15f（精确值 1/2 = %.15f）"
      % (mean_sin2, 0.5))
print("  有效值（RMS）= √(1/2) = %.15f" % rms)
print("  1/√2 = %.15f" % (1 / math.sqrt(2)))
print("  ★ 峰值 1 V 的正弦，有效值只有 0.7071 V —— 为什么家电标 220V 而峰值是 311V")
print("    答案就在这里（220 × √2 = %.4f），见 elec 的数字信号与通信篇" % (220 * math.sqrt(2)))

预期输出：

=== ① ∫_0^1 x^2 dx，精确值 = 1/3 ===
  精确值 1/3 = 0.333333333333333
  n       黎曼和            梯形法            辛普森法          辛普森误差
  10      0.285000000000000 0.335000000000000 0.333333333333333 0.000e+00
  100     0.328350000000000 0.333350000000000 0.333333333333333 1.110e-16
  1000    0.332833500000000 0.333333500000000 0.333333333333333 1.665e-16

  n 增大到 10 倍时的误差变化：
  黎曼和    4.833e-02 → 4.983e-03 → 4.998e-04   缩减比 9.7 / 10.0
  梯形法    1.667e-03 → 1.667e-05 → 1.667e-07   缩减比 100.0 / 100.0
  辛普森法  0.000e+00 → 1.110e-16 → 1.665e-16   缩减比 0.0 / 0.7
  ★ 缩减比就告诉我们阶数：黎曼和 ≈ 10 倍（误差 ∝ h，即 O(h)）；
    梯形法 ≈ 100 倍（误差 ∝ h^2，即 O(h^2)）；辛普森法对 x^2 已精确到机器精度，看不出阶
    —— 是因为辛普森法对次数 ≤ 3 的多项式「精确成立」，不是近似

=== ② 用积分估 π：∫_0^1 4/(1+x^2) dx = π ===
  n       辛普森近似        与 π 的差     有效位数
  4       3.141568627450981 2.403e-05     4.6 位
  8       3.141592502458707 1.511e-07     6.8 位
  16      3.141592651224822 2.365e-09     8.6 位
  64      3.141592653589215 5.778e-13     12.2 位
  π = 3.141592653589793

=== ③ 平均值与有效值（正弦量的两个积分） ===
  平均值 = (1/2π)∫_0^2π sin t dt = 0.000000000000000（精确值 0，正负半周抵消）
  均方值 = (1/2π)∫_0^2π sin^2 t dt = 0.500000000000001（精确值 1/2 = 0.500000000000000）
  有效值（RMS）= √(1/2) = 0.707106781186548
  1/√2 = 0.707106781186547
  ★ 峰值 1 V 的正弦，有效值只有 0.7071 V —— 为什么家电标 220V 而峰值是 311V
    答案就在这里（220 × √2 = 311.1270），见 elec 的数字信号与通信篇

例 4：泰勒展开——硬件里就是这么算 exp 和 sqrt 的 ​

python
import math, unicodedata

def w(s):
    return sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in s)

def pad(s, n):
    return s + " " * max(0, n - w(s))

def exp_partial(x, n):            # e^x 的前 n 项部分和（第 n 项为止）
    s, term = 0.0, 1.0
    for k in range(n + 1):
        s += term
        term *= x / (k + 1)
    return s

print("=== ① e^x 的麦克劳林部分和：项数与误差 ===")
print("  " + pad("x", 8) + pad("1 项", 18) + pad("3 项", 18) + pad("5 项", 18)
      + pad("10 项", 18) + "真值")
for x in (0.5, 1.0, 2.0, 5.0, -3.0):
    cells = [exp_partial(x, n) for n in (1, 3, 5, 10)]
    print("  " + pad("%.1f" % x, 8)
          + "".join(pad("%.10f" % c, 18) for c in cells)
          + "%.10f" % math.exp(x))
print()
print("  x = 5 时 10 项还差多少：")
for n in (1, 3, 5, 10, 15, 20):
    e = abs(exp_partial(5.0, n) - math.exp(5.0))
    print("    取 %2d 项：误差 = %.3e" % (n, e))
print("  ★ e^5 = %.6f 是个大数，所以「相对误差」才是有意义的指标：" % math.exp(5.0))
for n in (5, 10, 15, 20):
    rel = abs(exp_partial(5.0, n) - math.exp(5.0)) / math.exp(5.0)
    print("    取 %2d 项：相对误差 = %.3e" % (n, rel))
print("  ★ x 为负（-3）时，各项正负交替、绝对值先增后减 → 中间项被放大，")
print("    所以实现 exp 时先把 x 归约到小范围（区间压缩），再展开")

print()
print("=== ② 一阶近似（线性化）：工程上的默认动作 ===")
print("  " + pad("x", 10) + pad("sin x", 18) + pad("近似 x", 18) + pad("相对误差", 12) + "放大 10 倍后")
for x in (0.001, 0.01, 0.1, 0.5, 1.0):
    approx = x
    rel = abs(math.sin(x) - approx) / math.sin(x)
    print("  " + pad("%.3f" % x, 10) + pad("%.15f" % math.sin(x), 18) + pad("%.15f" % approx, 18)
          + pad("%.3e" % rel, 12) + "%.3e" % (rel * 10))
print("  ★ 误差 ≈ x^2/6：x 每缩小 10 倍，误差缩小 100 倍（这是二阶小量）")

print()
print("=== ③ 用泰勒算 sqrt(1+x)（牛顿迭代的起点也这么做） ===")
print("  sqrt(1+x) ≈ 1 + x/2 − x^2/8 + x^3/16 − ⋯")
for x in (0.01, 0.1, 0.21, 0.5, 1.0):
    s2 = 1 + x / 2 - x * x / 8
    s3 = s2 + x ** 3 / 16
    real = math.sqrt(1 + x)
    print("  x=%.2f：二次近似 %.12f（误差 %.3e）；三次近似 %.12f（误差 %.3e）；真值 %.12f"
          % (x, s2, abs(s2 - real), s3, abs(s3 - real), real))
print("  ★ 代码里写 sqrt(1.21) 得到 1.1，而二次近似给 %.12f —— 差 %.4f%%"
      % (1 + 0.21 / 2 - 0.21 ** 2 / 8,
         abs((1 + 0.21 / 2 - 0.21 ** 2 / 8) - 1.1) / 1.1 * 100))
print("  ★ 注意 x = 1 时二次近似误差还有 3.9e-2 —— 因为 sqrt(1+x) 的级数收敛半径正好是 1，")
print("    越靠近边界收敛越慢；所以硬件做法是先把 x 归约到小范围（如 ≤ 1/4），")
print("    用低次近似拿到「够好的初值」，再用牛顿迭代把精度拉满")

预期输出：

=== ① e^x 的麦克劳林部分和：项数与误差 ===
  x       1 项              3 项              5 项              10 项             真值
  0.5     1.5000000000      1.6458333333      1.6486979167      1.6487212707      1.6487212707
  1.0     2.0000000000      2.6666666667      2.7166666667      2.7182818011      2.7182818285
  2.0     3.0000000000      6.3333333333      7.2666666667      7.3889947090      7.3890560989
  5.0     6.0000000000      39.3333333333     91.4166666667     146.3806010251    148.4131591026
  -3.0    -2.0000000000     -2.0000000000     -0.6500000000     0.0533258929      0.0497870684

  x = 5 时 10 项还差多少：
    取  1 项：误差 = 1.424e+02
    取  3 项：误差 = 1.091e+02
    取  5 项：误差 = 5.700e+01
    取 10 项：误差 = 2.033e+00
    取 15 项：误差 = 1.024e-02
    取 20 项：误差 = 1.204e-05
  ★ e^5 = 148.413159 是个大数，所以「相对误差」才是有意义的指标：
    取  5 项：相对误差 = 3.840e-01
    取 10 项：相对误差 = 1.370e-02
    取 15 项：相对误差 = 6.901e-05
    取 20 项：相对误差 = 8.109e-08
  ★ x 为负（-3）时，各项正负交替、绝对值先增后减 → 中间项被放大，
    所以实现 exp 时先把 x 归约到小范围（区间压缩），再展开

=== ② 一阶近似（线性化）：工程上的默认动作 ===
  x         sin x             近似 x            相对误差    放大 10 倍后
  0.001     0.000999999833333 0.001000000000000 1.667e-07   1.667e-06
  0.010     0.009999833334167 0.010000000000000 1.667e-05   1.667e-04
  0.100     0.099833416646828 0.100000000000000 1.669e-03   1.669e-02
  0.500     0.479425538604203 0.500000000000000 4.291e-02   4.291e-01
  1.000     0.841470984807897 1.000000000000000 1.884e-01   1.884e+00
  ★ 误差 ≈ x^2/6：x 每缩小 10 倍，误差缩小 100 倍（这是二阶小量）

=== ③ 用泰勒算 sqrt(1+x)（牛顿迭代的起点也这么做） ===
  sqrt(1+x) ≈ 1 + x/2 − x^2/8 + x^3/16 − ⋯
  x=0.01：二次近似 1.004987500000（误差 6.211e-08）；三次近似 1.004987562500（误差 3.879e-10）；真值 1.004987562112
  x=0.10：二次近似 1.048750000000（误差 5.885e-05）；三次近似 1.048812500000（误差 3.652e-06）；真值 1.048808848170
  x=0.21：二次近似 1.099487500000（误差 5.125e-04）；三次近似 1.100066312500（误差 6.631e-05）；真值 1.100000000000
  x=0.50：二次近似 1.218750000000（误差 5.995e-03）；三次近似 1.226562500000（误差 1.818e-03）；真值 1.224744871392
  x=1.00：二次近似 1.375000000000（误差 3.921e-02）；三次近似 1.437500000000（误差 2.329e-02）；真值 1.414213562373
  ★ 代码里写 sqrt(1.21) 得到 1.1，而二次近似给 1.099487500000 —— 差 0.0466%
  ★ 注意 x = 1 时二次近似误差还有 3.9e-2 —— 因为 sqrt(1+x) 的级数收敛半径正好是 1，
    越靠近边界收敛越慢；所以硬件做法是先把 x 归约到小范围（如 ≤ 1/4），
    用低次近似拿到「够好的初值」，再用牛顿迭代把精度拉满

例 5：微分方程——RC 充电的解析解与欧拉法对账 ​

任务：解 RC dV/dt + V = V_S，把解析解与数值解逐点比对，并核对 circuit/02-rc.md 用过的 t50 = 0.6931τ。

python
import math, unicodedata

def w(s):
    return sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in s)

def pad(s, n):
    return s + " " * max(0, n - w(s))

RC, VS = 1.0, 5.0
exact = lambda t: VS * (1 - math.exp(-t / RC))

def euler(h, T=5.0):
    """欧拉法：V_{k+1} = V_k + h·(VS − V_k)/RC"""
    n = int(round(T / h))
    v = 0.0
    for _ in range(n):
        v += h * (VS - v) / RC
    return v

print("=== ① 解析解（分离变量解得） ===")
print("  RC dV/dt + V = VS，V(0) = 0")
print("  ⇒ dV/dt = (VS − V)/RC ⇒ dV/(VS − V) = dt/RC")
print("  ⇒ −ln(VS − V) = t/RC + C1 ⇒ V(t) = VS (1 − e^(−t/RC))")
print("  取 RC = %.1f，VS = %.1f：" % (RC, VS))
print("  " + pad("t / RC", 10) + pad("V(t) 解析", 16) + pad("V(t)/VS", 16) + "说明")
for k in (0, 1, 2, 3, 4, 5):
    t = k * RC
    print("  " + pad("%d" % k, 10) + pad("%.12f" % exact(t), 16)
          + pad("%.12f" % (exact(t) / VS), 16)
          + ("起点" if k == 0 else ""))

print()
print("=== ② 两个关键时间点（circuit/02-rc.md 的锚点） ===")
ln2 = math.log(2)
ln9 = math.log(9)
print("  V = 0.5 VS 时：1 − e^(−t/RC) = 0.5 ⇒ t = RC·ln2")
print("    ln2 = %.15f，RC·ln2 = %.6f τ —— 与 circuit/02-rc.md 的 0.6931τ 一致" % (ln2, ln2))
print("  V 从 10% 升到 90%：t = RC·(ln9 − ln1) = RC·ln9")
print("    ln9 = %.15f，RC·ln9 = %.6f τ —— 与 2.1972τ 一致" % (ln9, ln9))
print("  校验解析式：V(RC·ln2) = %.12f（应等于 %.1f 的一半）" % (exact(ln2), VS))

print()
print("=== ③ 欧拉法：步长与误差（一阶精度） ===")
T = 5.0
target = exact(T)
print("  目标：t = %.1f 时的精确解 = %.12f" % (T, target))
print("  " + pad("h", 10) + pad("步数", 8) + pad("欧拉解", 16) + pad("误差", 14) + "误差比")
prev = None
for h in (0.5, 0.25, 0.125, 0.0625, 0.01):
    v = euler(h, T)
    err = abs(v - target)
    ratio = "—" if prev is None else "%.3f" % (err / prev)
    print("  " + pad("%g" % h, 10) + pad("%d" % int(round(T / h)), 8)
          + pad("%.12f" % v, 16) + pad("%.3e" % err, 14) + ratio)
    prev = err
print("  ★ 步长每减半，误差大致减半 → 欧拉法是一阶方法（O(h)）")
print("  ★ 顺带验证「t = 5τ 时 V 已充到 %.4f%%」—— 这就是「5τ 认为充满」的由来"
      % (target / VS * 100))

print()
print("=== ④ 二阶特征方程：三句话定行为（给 auto 铺路） ===")
print("  " + pad("方程", 20) + pad("特征根", 22) + pad("解的形状", 26) + "行为")
CASES = [
    ("y'' + 3y' + 2y = 0", "λ = −1, −2", "C1 e^(−t) + C2 e^(−2t)", "过阻尼（两个实根）"),
    ("y'' + 2y' + y = 0", "λ = −1（重根）", "(C1 + C2 t) e^(−t)", "临界阻尼"),
    ("y'' + 2y' + 5y = 0", "λ = −1 ± 2i", "e^(−t)(C1 cos2t + C2 sin2t)", "欠阻尼（共轭复根）"),
    ("y'' − y = 0", "λ = ±1", "C1 e^(t) + C2 e^(−t)", "不稳定（有正实部）"),
]
for eq, roots, form, beh in CASES:
    print("  " + pad(eq, 20) + pad(roots, 22) + pad(form, 26) + beh)
print("  ★ 判据：特征根实部全负 ⇒ 衰减 ⇒ 稳定；有一个正实部 ⇒ 发散 ⇒ 不稳定")

预期输出：

=== ① 解析解（分离变量解得） ===
  RC dV/dt + V = VS，V(0) = 0
  ⇒ dV/dt = (VS − V)/RC ⇒ dV/(VS − V) = dt/RC
  ⇒ −ln(VS − V) = t/RC + C1 ⇒ V(t) = VS (1 − e^(−t/RC))
  取 RC = 1.0，VS = 5.0：
  t / RC    V(t) 解析       V(t)/VS         说明
  0         0.000000000000  0.000000000000  起点
  1         3.160602794143  0.632120558829  
  2         4.323323583817  0.864664716763  
  3         4.751064658161  0.950212931632  
  4         4.908421805556  0.981684361111  
  5         4.966310265005  0.993262053001  

=== ② 两个关键时间点（circuit/02-rc.md 的锚点） ===
  V = 0.5 VS 时：1 − e^(−t/RC) = 0.5 ⇒ t = RC·ln2
    ln2 = 0.693147180559945，RC·ln2 = 0.693147 τ —— 与 circuit/02-rc.md 的 0.6931τ 一致
  V 从 10% 升到 90%：t = RC·(ln9 − ln1) = RC·ln9
    ln9 = 2.197224577336220，RC·ln9 = 2.197225 τ —— 与 2.1972τ 一致
  校验解析式：V(RC·ln2) = 2.500000000000（应等于 5.0 的一半）

=== ③ 欧拉法：步长与误差（一阶精度） ===
  目标：t = 5.0 时的精确解 = 4.966310265005
  h         步数    欧拉解          误差          误差比
  0.5       10      4.995117187500  2.881e-02     —
  0.25      20      4.984143940305  1.783e-02     0.619
  0.125     40      4.976050738545  9.740e-03     0.546
  0.0625    80      4.971379836113  5.070e-03     0.520
  0.01      500     4.967147584788  8.373e-04     0.165
  ★ 步长每减半，误差大致减半 → 欧拉法是一阶方法（O(h)）
  ★ 顺带验证「t = 5τ 时 V 已充到 99.3262%」—— 这就是「5τ 认为充满」的由来

=== ④ 二阶特征方程：三句话定行为（给 auto 铺路） ===
  方程                特征根                解的形状                  行为
  y'' + 3y' + 2y = 0  λ = −1, −2            C1 e^(−t) + C2 e^(−2t)    过阻尼（两个实根）
  y'' + 2y' + y = 0   λ = −1（重根）        (C1 + C2 t) e^(−t)        临界阻尼
  y'' + 2y' + 5y = 0  λ = −1 ± 2i           e^(−t)(C1 cos2t + C2 sin2t)欠阻尼（共轭复根）
  y'' − y = 0         λ = ±1                C1 e^(t) + C2 e^(−t)      不稳定（有正实部）
  ★ 判据：特征根实部全负 ⇒ 衰减 ⇒ 稳定；有一个正实部 ⇒ 发散 ⇒ 不稳定

考点 ​

考点

1. 两个重要极限（默写）

  • lim_{x→0} sin x / x = 1——小角度近似 sin x ≈ x 的依据；
  • lim_{n→∞} (1 + 1/n)^n = e = 2.718281828——e 的定义式。

2. 等价无穷小替换表（x→0）

sin x ~ x、tan x ~ x、ln(1+x) ~ x、e^x − 1 ~ x、1 − cos x ~ x²/2、(1+x)^α − 1 ~ αx。

⚠️ 只对"乘除因子"成立——(sin x − x)/x³ → −1/6，硬替换会算成 0。

3. 求导法则（七条）

幂、指数、对数、正余弦、乘积 (uv)' = u'v + uv'、商、链式 [f(g(x))]' = f'(g(x))g'(x)。

极值判别：f'=0 是必要条件不是充分条件；二阶判据 f''<0 极大、f''>0 极小。

洛必达的两个前提：① 0/0 或 ∞/∞；② 导数之比的极限要存在。

4. 积分的三张表

被积原函数
x^n（n≠−1）x^{n+1}/(n+1)
1/xln∣x∣
e^xe^x
sin x−cos x
1/(1+x²)arctan x
  • 牛顿-莱布尼茨：∫_a^b f = F(b) − F(a)；
  • 分部积分：∫u dv = uv − ∫v du；
  • 平均值：\bar f = ∫_a^b f / (b−a)（os 平均等待时间、elec 有效值都靠这条）。

5. 泰勒展开（五个必背 + 一个用途）

e^x、sin x、cos x、ln(1+x)、1/(1−x) 的展开式。 工程用途：硬件里的 exp/sin/sqrt 全是"区间压缩 + 泰勒 + 迭代"。

  • 一阶近似（线性化）：f(x₀+Δx) ≈ f(x₀) + f'(x₀)Δx——小信号模型、控制系统线性化的通用工具；
  • 误差量级由"下一项"决定：sin x ≈ x 的相对误差 ≈ x²/6（x 缩小 10 倍，误差缩小 100 倍）。

6. 微分方程与稳定性

  • 一阶 RC：RC dV/dt + V = V_S → V = V_S(1 − e^{−t/RC})；
  • 由此得 t50 = τ ln2 ≈ 0.6931τ、t_r(10%→90%) = τ ln9 ≈ 2.1972τ——与 circuit/02-rc.md 完全一致；
  • 二阶特征方程 aλ² + bλ + c = 0：两实根（过阻尼）/ 重根（临界）/ 共轭复根（欠阻尼振荡）；
  • 稳定判据：特征根实部全负 ⟺ 系统稳定——auto 里"极点在左半平面"的原话。

7. 数值方法（本课唯一"能用代码验"的部分）

方法精度备注
前向差分求导O(h)最省事但最不准
中心差分求导O(h²)同一 h 下比前向准 1~2 个量级
黎曼和（左/右端点矩形）O(h)n 增 10 倍误差只降 10 倍
梯形法积分O(h²)n 增 10 倍误差降 100 倍
辛普森法积分O(h⁴)n 增 10 倍误差降 10000 倍；对 ≤3 次多项式精确
欧拉法解微分方程O(h)步长减半误差减半

8. 本节六个高频易错点

  • ε-δ 里 ε 与 δ 的角色别反：ε 是你给的精度要求，δ 是找出来的邻域半径；
  • ∫ dx/x = ln|x| 的绝对值不能丢（x<0 时 ln x 无定义）；
  • 不定积分的 +C 对应初始条件，丢 C 就没法定解；
  • 洛必达不是万能：不是不定式、或右边极限不存在时硬套会错；
  • sin x ≈ x 有量纲要求：x 必须是弧度——用角度算会差 57 倍；
  • 数值求导的 h 不能一味取小：太小反而被舍入误差吃掉（最优 h 在 1e-5 附近）。

小结 ​

  • 微积分 = 连续的数学，与 math/01-discrete.md 的离散数学互补：离散给 L0/L1 打地基，连续给 elec/auto 打地基。
  • 极限是地基：两个重要极限 sin x/x → 1、(1+1/n)^n → e；等价无穷小只能替换乘除因子。
  • 导数 = 变化率：七条法则 + 链式法则；极值判别、中值定理、洛必达（两个前提）。
  • 积分 = 累积：牛顿-莱布尼茨把"求和的极限"变成两步减法；平均值 = 积分 ÷ 区间长度。
  • 泰勒展开是工程上最值钱的一节：硬件算 exp/sin/sqrt 全靠它；一阶近似就是"线性化"。
  • 微分方程：一阶 RC 的解 V = V_S(1−e^{−t/RC}) 直接给出 t50 = τln2 = 0.6931τ；二阶看特征根，实部全负才稳定。
  • 数值方法有精度阶：欧拉 O(h)、中心差分与梯形 O(h²)、辛普森 O(h⁴)——"步长减半，误差怎么变"就是判阶的方法。
  • 三个手算锚点：∫_0^1 x²dx = 1/3；∫_0^1 4/(1+x²)dx = π；正弦的 RMS = 1/√2 ≈ 0.7071（220 V 对应峰值 311.13 V）。

回到主线：这一篇是"工具箱"的第二格抽屉。

它把 L1 里两个"只用过一次就搁下"的东西补上了出处： ① circuit/02-rc.md 的 t50 = 0.6931τ——那不是查表来的，是把 RC dV/dt + V = V_S 解出来得到的 τ ln2；② circuit/03-analog.md 的"小信号模型"——那就是一阶泰勒近似 f(x₀+Δx) ≈ f(x₀) + f'(x₀)Δx。

同时它给后面的三门课备好了工具：elec 的卷积与傅里叶变换是积分、auto 的控制系统是微分方程 + 特征根、arch 的性能分析里到处是极限。

⚠️ 但它不是"独立体系"：math 这门课的原则是"主线用到什么就补什么"——所以下面几篇也是"按需取用"：线性代数给 soft 的图形学与机器学习，概率统计给 arch 的命中率与 ds 的散列分析，复变函数给 elec 的变换。

下一篇是线性代数：矩阵乘法为什么是"行乘列"？为什么"秩"决定了方程组有没有唯一解？特征值到底在描述什么？ 这三个问题一次讲清——它们分别对应"变换的复合""信息的冗余度""变换的不变方向"。

下一篇：线性代数：矩阵运算、向量空间、特征值

我的笔记

当前浏览器不允许本地存储，笔记无法保存。

评论（0）

当前浏览器不允许本地存储，评论无法保存。

还没有评论，来说两句。

内容以 CC BY-NC-SA 4.0 共享

Si2C · 由硅到 C