为什么放编程分类

这篇不是大学数学课本的目录——而是程序员的数学工具书。做技术博客分类时，我没把它放进「数学/科学」大类，而是放在「编程」下面，理由有三：

1. 公式不是用来考试——是写代码时查表用的。看到 Σ、∂、lim 就知道在写什么，看到 T(n) = O(n²) 就能在 code review 里挑出性能 bug
2. 数学是计算机的母语——所有算法、数据结构、机器学习、图形学、密码学底层都是这一套符号 + 公式。不会这套符号就读不懂 RFC、论文、源码注释
3. 学习路径配套——本站点「算法 / 数据结构」「机器学习」「密码学」「游戏开发」等分类的前置知识就是这一页。先建索引，再深入分支

所以这篇的定位是：

放办公桌的"数学速查表"——遇到不熟的符号翻 30 秒，回到 IDE 继续写代码。

下面这张表汇总了 5 个最常见的工程场景对应的数学分支，方便按需跳转：

常用数学符号

集合与逻辑

集合运算律

• 交换律：$A \cup B = B \cup A$，$A \cap B = B \cap A$
• 结合律：$(A \cup B) \cup C = A \cup (B \cup C)$
• 分配律：$A \cap (B \cup C) = (A \cap B) \cup (A \cap C)$
• 德摩根：$\overline{A \cup B} = \overline{A} \cap \overline{B}$

命题逻辑

初等代数

乘法公式

一元二次方程 $ax^2 + bx + c = 0$

• 判别式：$\Delta = b^2 - 4ac$
• 根：$x = \frac{-b \pm \sqrt{\Delta}}{2a}$
• 韦达：$x_1 + x_2 = -\frac{b}{a}$，$x_1 x_2 = \frac{c}{a}$

指数

对数

三角恒等式

基本关系：

和差角：

二倍角：

半角：

和差化积：

解三角形

• 正弦定理：$\frac{a}{\sin A} = \frac{b}{\sin B} = \frac{c}{\sin C} = 2R$
• 余弦定理：$c^2 = a^2 + b^2 - 2ab \cos C$
• 三角形面积：$S = \frac{1}{2}ab \sin C = \frac{abc}{4R}$

解析几何

直线

• 点斜式：$y - y_0 = k(x - x_0)$
• 斜截式：$y = kx + b$
• 一般式：$Ax + By + C = 0$
• 两点距离：$d = \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}$
• 点到直线：$d = \frac{|Ax_0 + By_0 + C|}{\sqrt{A^2 + B^2}}$

圆

• 标准：$(x-a)^2 + (y-b)^2 = r^2$
• 一般：$x^2 + y^2 + Dx + Ey + F = 0$
• 圆心：$(-\frac{D}{2}, -\frac{E}{2})$，$r = \frac{\sqrt{D^2 + E^2 - 4F}}{2}$

椭圆 $\frac{x^2}{a^2} + \frac{y^2}{b^2} = 1$

• $a > b > 0$
• 离心率 $e = c/a = \sqrt{1 - b^2/a^2}$
• 焦点 $F_1(-c, 0)$，$F_2(c, 0)$

双曲线 $\frac{x^2}{a^2} - \frac{y^2}{b^2} = 1$

• 离心率 $e = c/a = \sqrt{1 + b^2/a^2}$
• 渐近线 $y = \pm \frac{b}{a} x$

抛物线 $y^2 = 2px$

• 焦点 $(\frac{p}{2}, 0)$，准线 $x = -\frac{p}{2}$

微积分

极限

常用导数

常用积分

微分中值定理

• 罗尔：$f(a) = f(b)$，$\exists \xi \in (a, b)$，$f’(\xi) = 0$
• 拉格朗日：$\exists \xi$，$f’(\xi) = \frac{f(b)-f(a)}{b-a}$
• 柯西：$\exists \xi$，$\frac{f’(\xi)}{g’(\xi)} = \frac{f(b)-f(a)}{g(b)-g(a)}$

泰勒公式

常用展开：

线性代数

矩阵

• 行列式（2x2）：$\begin{vmatrix} a & b \ c & d \end{vmatrix} = ad - bc$
• 矩阵乘法：$(AB){ij} = \sum_k A{ik} B_{kj}$
• 矩阵转置：$(A^T){ij} = A{ji}$
• 矩阵求逆：$A^{-1} = \frac{1}{\det A} A^$（$A^$ 是伴随矩阵）

特征值与特征向量

重要矩阵

• 单位矩阵 $I$：对角线 1
• 零矩阵 $O$：全 0
• 对角矩阵 $\text{diag}(d_1, d_2, \ldots, d_n)$
• 对称矩阵 $A^T = A$
• 正交矩阵 $A^T A = I$

概率统计

概率公式

• 条件概率：$P(A|B) = \frac{P(AB)}{P(B)}$
• 全概率：$P(A) = \sum_i P(B_i) P(A|B_i)$
• 贝叶斯：$P(B_j|A) = \frac{P(B_j) P(A|B_j)}{\sum_i P(B_i) P(A|B_i)}$

常见分布

期望 / 方差性质

• $E(c) = c$，$E(aX + b) = aE(X) + b$
• $D(c) = 0$，$D(aX + b) = a^2 D(X)$
• 独立：$E(XY) = E(X)E(Y)$，$D(X+Y) = D(X) + D(Y)$

离散数学

集合

• $|A \cup B| = |A| + |B| - |A \cap B|$
• $|A \cup B \cup C| = |A|+|B|+|C| - |A \cap B| - |B \cap C| - |A \cap C| + |A \cap B \cap C|$

排列组合

• 排列：$P(n, k) = \frac{n!}{(n-k)!}$
• 组合：$C(n, k) = \binom{n}{k} = \frac{n!}{k!(n-k)!}$
• 性质：$C(n, k) = C(n, n-k)$，$C(n+1, k) = C(n, k) + C(n, k-1)$

鸽巢原理

把 $n+1$ 个物品放入 $n$ 个盒子，至少有一个盒子包含至少 2 个物品。

程序员常用

浮点数（IEEE 754）

• 单精度：32 位（1 符号 + 8 指数 + 23 尾数）
• 双精度：64 位（1 符号 + 11 指数 + 52 尾数）
• 精度：$2^{-23} \approx 1.19 \times 10^{-7}$（单精度）
• 舍入模式：最近偶数舍入（默认）

哈希

• 期望冲突：$\frac{k(k-1)}{2n}$（$k$ 个 key，$n$ 个 slot）
• 生日悖论：50% 冲突需要 $\approx 1.18\sqrt{n}$ 个 key

复杂度

• 主定理：$T(n) = aT(n/b) + f(n)$
  • 若 $f(n) = O(n^{\log_b a - \epsilon})$，$T(n) = \Theta(n^{\log_b a})$
  • 若 $f(n) = \Theta(n^{\log_b a})$，$T(n) = \Theta(n^{\log_b a} \log n)$
  • 若 $f(n) = \Omega(n^{\log_b a + \epsilon})$，$T(n) = \Theta(f(n))$

在 5 个工程场景的应用

这一节给上面零散的公式穿上工程外衣——每个场景都对应到具体的代码 / 库 / 工具，让公式不再停留在纸面。

场景 1：哈希表与布隆过滤器

哈希函数的核心是把任意 key 映射到 [0, n) 的 slot：

1
2
3
4
5
6
7
8
9

# Python dict 用的是开放寻址 + SipHash（防 hash flooding 攻击）
# 期望冲突数：E[collisions] = k(k-1) / (2n)  # k 个 key, n 个 slot
# 50% 冲突概率：k ≈ 1.177√n  # 生日悖论

import hashlib

def my_hash(key: str, n: int) -> int:
    h = hashlib.sha256(key.encode()).digest()
    return int.from_bytes(h[:4], 'big') % n

布隆过滤器用 k 个哈希函数 + m 位数组，假阳率：

场景 2：密码学 / RSA

RSA 依赖三个数论核心：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 1. 模逆：a*x ≡ 1 (mod p) → 用扩展欧几里得算法
def modinv(a, p):
    return pow(a, p - 2, p)  # 费马小定理，p 是质数

# 2. 欧拉函数：φ(n) = n * Π(1 - 1/p_i)
# 3. RSA：c = m^e mod n，m = c^d mod n  (其中 d = modinv(e, φ(n)))

# 实际用 PyCryptodome
from Crypto.PublicKey import RSA
key = RSA.generate(2048)
cipher = key.encrypt(b"hello", None)
plain = key.decrypt(cipher)

关键定理：欧拉定理 $a^{\phi(n)} \equiv 1 \pmod n$、费马小定理 $a^{p-1} \equiv 1 \pmod p$（p 是质数）。

场景 3：CRC / 校验和

CRC（Cyclic Redundancy Check）= 多项式除法的余数。以太网、ZIP、PNG 全用它。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# CRC-32 (以太网)
import zlib

data = b"hello world"
crc = zlib.crc32(data) & 0xffffffff  # 0x0d4a1185

# 手动算 CRC-8 (多项式 x^8 + x^2 + x + 1 = 0x07)
def crc8(data: bytes, poly=0x07, init=0x00) -> int:
    crc = init
    for byte in data:
        crc ^= byte
        for _ in range(8):
            crc = (crc >> 1) ^ (poly & -(crc & 1))
    return crc & 0xff

关键数学：有限域 GF(2⁸) 上的多项式模 2 除法。

场景 4：图像 / 音视频处理

旋转、缩放、JPEG 压缩、音频 EQ——全是三角函数 + 傅里叶变换。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 2D 旋转（围绕原点）
import math

def rotate(x, y, theta_deg):
    t = math.radians(theta_deg)
    return (x * math.cos(t) - y * math.sin(t),
            x * math.sin(t) + y * math.cos(t))

# 离散傅里叶变换（手写太慢，用 numpy）
import numpy as np

def spectrum(signal):
    return np.abs(np.fft.fft(signal))  # 时域 → 频域

关键公式：

• 欧拉公式：$e^{i\theta} = \cos\theta + i\sin\theta$
• 离散傅里叶：$X_k = \sum_{n=0}^{N-1} x_n \cdot e^{-2\pi i kn/N}$

场景 5：机器学习 / 深度学习

ML/DL 整个底层都依赖线性代数 + 概率 + 微积分。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 1. 矩阵乘法：神经网络的前向传播
import numpy as np

X = np.random.randn(64, 784)  # 64 个样本，784 维
W1 = np.random.randn(784, 128)
h = np.maximum(0, X @ W1)  # ReLU 激活

# 2. 梯度下降：∂L/∂W = (∂L/∂h) · (∂h/∂W)
# PyTorch 替你算
import torch
import torch.nn as nn

model = nn.Linear(784, 10)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for x, y in dataloader:
    pred = model(x)
    loss = loss_fn(pred, y)
    loss.backward()      # 反向传播（链式法则）
    optimizer.step()     # 梯度下降
    optimizer.zero_grad()

关键概念：

• 链式法则：$\frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial x}$（autograd 的数学基础）
• Softmax：$\sigma(z_i) = \frac{e^{z_i}}{\sum_j e^{z_j}}$（多分类概率化）
• 交叉熵：$H(p, q) = -\sum_i p_i \log q_i$（分类损失）

场景 6（赠送）：素数判定

密码学、哈希、布隆过滤器都依赖大素数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# Miller-Rabin 素性测试
import random

def is_prime(n, k=20):
    if n < 2: return False
    for p in [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]:
        if n % p == 0: return n == p
    d, r = n - 1, 0
    while d % 2 == 0:
        d //= 2
        r += 1
    for _ in range(k):
        a = random.randrange(2, n - 1)
        x = pow(a, d, n)
        if x == 1 or x == n - 1: continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1: break
        else:
            return False
    return True

上面 6 个场景的代码没有一个是"为了学数学而学数学"——全都是生产代码里会碰到的真实问题。数学不是装饰品，是工具。

下一步

• 微积分体系，看 2017-09-15《高等数学知识体系》
• 算法 / 数据结构，看 2012-08-17《常见排序算法完全指南》

参考资料

• 《数学手册》高等教育出版社
• 程序员数学入门：https://math.erucireu.dev/
• Wolfram MathWorld：https://mathworld.wolfram.com/