实验室/上册/第1章 函数与极限
CPP LAB · CHAPTER 01

函数与极限

极限定义里的 ∀ε>0, &exists;N 不是修辞,而是一个可以交给循环执行的搜索过程。本章用两个实验把「ε-N 语言」和「重要极限」变成程序输出。理论对照主站 第1章。

CASE 1.1 ε-N 定义的机器验证
数学:数列极限C++:线性搜索

定义说:对每个 ε 都存在 N。那就把定义倒过来跑——给定 ε 序列 {0.1, …, 10−6},从 n=1 起逐项检验 |(1+1/n)n − e| < ε,找到最小的 N。案例 2 则追踪迭代数列 xn+1 = √(2+xn) 的误差,算出它的收敛率。

code/ch01a_epsilon_n.cpp下载源码 ↓
// ch01a_epsilon_n.cpp —— 实验 1.1:ε-N 定义的机器验证
// 数学:数列极限 ∀ε>0 ∃N,当 n>N 时 |x_n − a| < ε
// 案例 1:a_n = (1+1/n)^n → e,对每个 ε 线性搜索最小 N
// 案例 2:迭代数列 x_{n+1} = √(2+x_n) → 2,观察二次收敛
#include <cstdio>
#include <cmath>

int main() {
    printf("== 实验 1.1 ε-N 定义的机器验证 ==\n\n");

    // ---- 案例 1:对每个 ε,找到让 |a_n − e| < ε 成立的最小 N ----
    printf("案例 1:a_n = (1+1/n)^n → e(n 从 1 起线性搜索)\n");
    printf("%10s %14s %22s\n", "ε", "找到的 N", "(1+1/N)^N − e");
    printf("------------------------------------------------------\n");
    const double E = std::exp(1.0);
    for (int p = 1; p <= 6; ++p) {
        double eps = std::pow(10.0, -p);
        long long n = 1;
        while (std::fabs(std::pow(1.0 + 1.0 / n, (double)n) - E) >= eps) ++n;
        printf("%10.0e %14lld %22.3e\n", eps, n,
               std::pow(1.0 + 1.0 / n, (double)n) - E);
    }
    printf("观察:ε 缩小 10 倍,N 大约增大 10 倍 —— 收敛速度为 O(1/n)。\n\n");

    // ---- 案例 2:迭代数列的收敛速度 ----
    printf("案例 2:x_{n+1} = sqrt(2 + x_n),x_1 = 0(极限为 2)\n");
    printf("%6s %22s %22s %16s\n", "n", "x_n", "e_n = x_n − 2", "e_n / e_{n-1}^2");
    printf("--------------------------------------------------------------\n");
    double x = 0.0, ePrev = 2.0;               // e_1 = 0 − 2 = −2
    for (int n = 1; n <= 8; ++n) {
        double e = x - 2.0;
        printf("%6d %22.15f %22.3e", n, x, e);
        if (n > 1 && ePrev != 0.0)
            printf("%16.3f\n", e / (ePrev * ePrev)); else printf("%16s\n", "--");
        ePrev = e;
        x = std::sqrt(2.0 + x);
    }
    printf("观察:e_{n+1}/e_n → 0.354 ≈ 1/(2√2) = |g'(2)| —— 不动点迭代的收敛率\n");
    printf("      由导数决定(线性收敛);若 |g'| = 0 才会是平方级加速。\n");
    return 0;
}
▶ 编译运行输出
== 实验 1.1 ε-N 定义的机器验证 ==

案例 1:a_n = (1+1/n)^n → e(n 从 1 起线性搜索)
        ε    找到的 N        (1+1/N)^N − e
------------------------------------------------------
     1e-01             13             -9.768e-02
     1e-02            135             -1.000e-02
     1e-03           1359             -9.994e-04
     1e-04          13591             -1.000e-04
     1e-05         135913             -1.000e-05
     1e-06        1358611             -1.000e-06
观察:ε 缩小 10 倍,N 大约增大 10 倍 —— 收敛速度为 O(1/n)。

案例 2:x_{n+1} = sqrt(2 + x_n),x_1 = 0(极限为 2)
     n                    x_n        e_n = x_n − 2  e_n / e_{n-1}^2
--------------------------------------------------------------
     1      0.000000000000000             -2.000e+00              --
     2      1.414213562373095             -5.858e-01          -0.146
     3      1.847759065022573             -1.522e-01          -0.444
     4      1.961570560806461             -3.843e-02          -1.658
     5      1.990369453344394             -9.631e-03          -6.521
     6      1.997590912410345             -2.409e-03         -25.975
     7      1.999397637392408             -6.024e-04        -103.789
     8      1.999849403678289             -1.506e-04        -415.048
观察:e_{n+1}/e_n → 0.354 ≈ 1/(2√2) = |g'(2)| —— 不动点迭代的收敛率
      由导数决定(线性收敛);若 |g'| = 0 才会是平方级加速。

要点解析:案例 1 的表显示 ε 每缩小 10 倍、N 约增大 10 倍——这就是 O(1/n) 的收敛速度;案例 2 的误差比 en+1/en → 0.354 ≈ |g′(2)|,正好验证了不动点迭代收敛率定理:由迭代函数在不动点处的导数决定。

CASE 1.2 两个重要极限的数值逼近
数学:重要极限C++:数值表

把 limx→0 sinx/x = 1 与 limx→∞(1+1/x)x = e 各自的「逼近方向」打成表:前者 x 取 10−1…10−8,后者 x 取 10…108,观察误差如何缩到舍入边界。

code/ch01b_keylimits.cpp下载源码 ↓
// ch01b_keylimits.cpp —— 实验 1.2:两个重要极限的数值逼近
// 数学:lim_{x→0} sin x / x = 1;lim_{x→∞} (1+1/x)^x = e
// 用数值表直观展示“逼近”,并注明双精度的舍入下限
#include <cstdio>
#include <cmath>

int main() {
    printf("== 实验 1.2 两个重要极限的数值逼近 ==\n\n");

    // ---- 极限 I:x → 0 ----
    printf("极限 I:lim(x→0) sin x / x = 1\n");
    printf("%12s %22s %14s\n", "x", "sin(x)/x", "与 1 的差");
    printf("--------------------------------------------------\n");
    for (int k = 1; k <= 8; ++k) {
        double x = std::pow(10.0, -k);
        double r = std::sin(x) / x;
        printf("%12.0e %22.15f %14.3e\n", x, r, r - 1.0);
    }
    printf("观察:差随 x 线性缩小;到 1e-16 量级后被舍入误差淹没。\n\n");

    // ---- 极限 II:x → +∞ ----
    printf("极限 II:lim(x→+∞) (1+1/x)^x = e = %.15f\n", std::exp(1.0));
    printf("%12s %22s %14s\n", "x", "(1+1/x)^x", "与 e 的差");
    printf("--------------------------------------------------\n");
    for (int k = 1; k <= 8; ++k) {
        double x = std::pow(10.0, k);
        double r = std::pow(1.0 + 1.0 / x, x);
        printf("%12.0e %22.15f %14.3e\n", x, r, r - std::exp(1.0));
    }
    printf("观察:x 增大 10 倍,差约缩小到 1/10 —— 一阶收敛。\n");

    // ---- 舍入的直观感受 ----
    printf("\n附:1 + 1e-17 在双精度下就是 1,因此 (1+1/x)^x 的逼近在 x>1e16 后失效。\n");
    printf("    数值实验“看到极限”,也要看到机器的边界。\n");
    return 0;
}
▶ 编译运行输出
== 实验 1.2 两个重要极限的数值逼近 ==

极限 I:lim(x→0) sin x / x = 1
           x               sin(x)/x   与 1 的差
--------------------------------------------------
       1e-01      0.998334166468282     -1.666e-03
       1e-02      0.999983333416666     -1.667e-05
       1e-03      0.999999833333342     -1.667e-07
       1e-04      0.999999998333333     -1.667e-09
       1e-05      0.999999999983333     -1.667e-11
       1e-06      0.999999999999833     -1.666e-13
       1e-07      0.999999999999998     -1.665e-15
       1e-08      1.000000000000000      0.000e+00
观察:差随 x 线性缩小;到 1e-16 量级后被舍入误差淹没。

极限 II:lim(x→+∞) (1+1/x)^x = e = 2.718281828459045
           x              (1+1/x)^x   与 e 的差
--------------------------------------------------
       1e+01      2.593742460100002     -1.245e-01
       1e+02      2.704813829421528     -1.347e-02
       1e+03      2.716923932235594     -1.358e-03
       1e+04      2.718145926824926     -1.359e-04
       1e+05      2.718268237192297     -1.359e-05
       1e+06      2.718280469095753     -1.359e-06
       1e+07      2.718281694132082     -1.343e-07
       1e+08      2.718281798347358     -3.011e-08
观察:x 增大 10 倍,差约缩小到 1/10 —— 一阶收敛。

附:1 + 1e-17 在双精度下就是 1,因此 (1+1/x)^x 的逼近在 x>1e16 后失效。
    数值实验“看到极限”,也要看到机器的边界。

要点解析:极限 I 的差按 x 一次方缩小(因为 sinx/x = 1 − x²/6 + …,差其实是 x² 级);极限 II 一阶收敛。程序末尾的提醒是本实验室的宗旨:数值实验既看到极限,也看到机器的边界。