实验室/下册/第12章 无穷级数
CPP LAB · CHAPTER 12

无穷级数

级数是「用循环逼近无穷」的数学:部分和序列就是 for 循环的累加器。收敛的在数据里看清速度,发散的看到它怎么发散,收敛半径则划定「级数算法」的可用边界。理论对照主站 第12章。

CASE 12.1 部分和的敛散观察
数学:p 级数 / 调和级数C++:long long 循环

三个经典级数各跑一组截断:p 级数 Σ1/n²(→ π²/6)、调和级数 Σ1/n(发散,与 ln N 同阶)、交错级数 Σ(−1)n+1/n(→ ln 2)。N 扫到 10⁸,敛与散都看得一清二楚。

code/ch12a_series.cpp下载源码 ↓
// ch12a_series.cpp —— 实验 12.1:级数敛散性的数值观察
// 数学:p 级数 Σ1/n² 收敛(π²/6)、调和级数 Σ1/n 发散、
//       交错级数 Σ(−1)^{n+1}/n 条件收敛(ln 2)
#include <cstdio>
#include <cmath>

const double PI    = 3.14159265358979323846;
const double PI2_6 = PI * PI / 6.0;      // ≈ 1.6449

int main() {
    printf("== 实验 12.1 部分和的敛散观察 ==\n\n");

    // ---- 1. p 级数:收敛 ----
    printf("[1] Σ 1/n² → π²/6 = %.10f\n", PI2_6);
    printf("%10s %18s %14s\n", "N(截断)", "部分和 S_N", "S_N − π²/6");
    printf("----------------------------------------\n");
    long long ns[] = {100, 10000, 1000000, 100000000};
    for (long long N : ns) {
        double s = 0.0;
        for (long long n = 1; n <= N; ++n) s += 1.0 / ((double)n * n);
        printf("%10lld %18.10f %14.3e\n", N, s, s - PI2_6);
    }
    printf("    尾项 ~ 1/N:想再准一位,代价 ×10 —— 收敛慢是 p 级数的宿命。\n\n");

    // ---- 2. 调和级数:发散(与 ln N 同阶)----
    printf("[2] Σ 1/n(调和级数,发散):\n");
    printf("%10s %18s %16s\n", "N(截断)", "部分和 H_N", "H_N − ln N");
    printf("--------------------------------------------\n");
    for (long long N : ns) {
        double s = 0.0;
        for (long long n = 1; n <= N; ++n) s += 1.0 / (double)n;
        printf("%10lld %18.10f %16.10f\n", N, s, s - std::log((double)N));
    }
    printf("    H_N − ln N → 欧拉常数 γ ≈ 0.5772 —— 增长“恰好”是对数级。\n\n");

    // ---- 3. 交错级数:条件收敛 ----
    printf("[3] Σ (−1)^{n+1}/n(交错级数 → ln 2 = %.10f)\n", std::log(2.0));
    printf("%10s %18s %14s\n", "N", "部分和 S_N", "S_N − ln 2");
    printf("----------------------------------------\n");
    for (long long N : ns) {
        double s = 0.0;
        for (long long n = 1; n <= N; ++n) s += ((n & 1) ? 1.0 : -1.0) / (double)n;
        printf("%10lld %18.10f %14.3e\n", N, s, s - std::log(2.0));
    }
    printf("    偶奇两项夹住 ln 2(莱布尼茨定理的“夹逼”可视化)。\n");
    return 0;
}
▶ 编译运行输出
== 实验 12.1 部分和的敛散观察 ==

[1] Σ 1/n² → π²/6 = 1.6449340668
N(截断)      部分和 S_N S_N − π²/6
----------------------------------------
       100       1.6349839002     -9.950e-03
     10000       1.6448340718     -1.000e-04
   1000000       1.6449330668     -1.000e-06
 100000000       1.6449340578     -9.014e-09
    尾项 ~ 1/N:想再准一位,代价 ×10 —— 收敛慢是 p 级数的宿命。

[2] Σ 1/n(调和级数,发散):
N(截断)      部分和 H_N     H_N − ln N
--------------------------------------------
       100       5.1873775176     0.5822073317
     10000       9.7876060360     0.5772656641
   1000000      14.3927267229     0.5772161649
 100000000      18.9978964139     0.5772156699
    H_N − ln N → 欧拉常数 γ ≈ 0.5772 —— 增长“恰好”是对数级。

[3] Σ (−1)^{n+1}/n(交错级数 → ln 2 = 0.6931471806)
         N      部分和 S_N   S_N − ln 2
----------------------------------------
       100       0.6881721793     -4.975e-03
     10000       0.6930971831     -5.000e-05
   1000000       0.6931466806     -5.000e-07
 100000000       0.6931471756     -5.000e-09
    偶奇两项夹住 ln 2(莱布尼茨定理的“夹逼”可视化)。

要点解析:p 级数尾项 ~1/N(想多一位精度要 ×10 计算量——收敛慢);调和级数的 Hₙ − ln N 逼近欧拉常数 γ≈0.5772(发散也「有规律」);交错级数的部分和被 ln 2 夹在中间——莱布尼茨定理的可视化。

CASE 12.2 泰勒级数与收敛半径
数学:e^x / ln(1+x)C++:递推求项

ex = Σxn/n! 全轴收敛——项间递推 tn+1 = tn·x/(n+1) 让阶乘永不重算;而 ln(1+x) 的级数收敛半径只有 1——x=2 时部分和肉眼可见地发散,收敛半径不是理论装饰,而是算法开关。

code/ch12b_taylor_exp.cpp下载源码 ↓
// ch12b_taylor_exp.cpp —— 实验 12.2:泰勒级数的计算与收敛半径
// 数学:e^x = Σ xⁿ/n!(全轴收敛);ln(1+x) = Σ(−1)^{n+1} xⁿ/n(仅 |x|<1!)
// 编程要点:项间递推 t_{n+1} = t_n · x/(n+1),避免重复计算阶乘
#include <cstdio>
#include <cmath>

// 泰勒级数求 e^x:|t_n| < 1e-16 时截断
double taylorExp(double x) {
    double term = 1.0, sum = 1.0;
    for (int n = 1; ; ++n) {
        term *= x / n;                    // 递推:不重算阶乘
        sum += term;
        if (std::fabs(term) < 1e-16) break;
        if (n > 500) break;               // 保险丝
    }
    return sum;
}

// ln(1+x) 的麦克劳林级数(只在 |x|<1 收敛)
double taylorLn(double x) {
    double term = x, sum = x;
    for (int n = 2; n <= 100; ++n) {
        term *= -x;
        sum += term / n;
    }
    return sum;
}

int main() {
    printf("== 实验 12.2 泰勒级数:优雅与边界 ==\n\n");

    printf("[1] e^x = Σ xⁿ/n!(自适应截断)\n");
    printf("%8s %20s %20s %12s\n", "x", "级数值", "cmath exp(x)", "相对误差");
    printf("------------------------------------------------------------\n");
    double xs[] = {0.5, 1.0, 2.0, 5.0, 10.0, -5.0};
    for (double x : xs) {
        double v = taylorExp(x), e = std::exp(x);
        printf("%8.1f %20.14f %20.14f %12.2e\n",
               x, v, e, std::fabs(v - e) / std::fabs(e));
    }
    printf("    任意 x 都能到机器精度 —— 收敛半径 ∞ 的红利。\n\n");

    printf("[2] ln(1+x) = Σ(−1)^{n+1} xⁿ/n(收敛半径 = 1)\n");
    printf("%8s %20s %20s %12s\n", "x", "100 项部分和", "cmath log(1+x)", "误差");
    printf("------------------------------------------------------------\n");
    double xs2[] = {0.3, 0.5, 0.9, 1.0, 2.0};
    for (double x : xs2) {
        double v = taylorLn(x), e = std::log(1.0 + x);
        printf("%8.1f %20.10f %20.10f %12.3e\n",
               x, v, e, std::fabs(v - e));
    }
    printf("    x=0.9 勉强收敛、x=1 缓慢发散边缘、x=2 完全发散 —— 收敛半径\n");
    printf("    不是理论装饰,而是“这个算法能不能用”的分界线。\n\n");

    printf("[3] 应对策略:换展开点。ln(2) = ln(1+0.5)+ln(1+0.333)…\n");
    printf("    实用公式 ln 2 = 2·[0.5 + 0.5³/3 + 0.5⁵/5 + …]:\n");
    double s = 0.0;
    for (int k = 0; k < 30; ++k) s += std::pow(0.5, 2 * k + 1) / (2 * k + 1);
    printf("    30 项得 ln 2 ≈ %.12f(cmath: %.12f)✓\n",
           2 * s, std::log(2.0));
    return 0;
}
▶ 编译运行输出
== 实验 12.2 泰勒级数:优雅与边界 ==

[1] e^x = Σ xⁿ/n!(自适应截断)
       x            级数值         cmath exp(x) 相对误差
------------------------------------------------------------
     0.5     1.64872127070013     1.64872127070013     2.69e-16
     1.0     2.71828182845905     2.71828182845905     1.63e-16
     2.0     7.38905609893065     7.38905609893065     2.40e-16
     5.0   148.41315910257660   148.41315910257660     0.00e+00
    10.0 22026.46579480671426 22026.46579480671789     1.65e-16
    -5.0     0.00673794699908     0.00673794699909     1.22e-13
    任意 x 都能到机器精度 —— 收敛半径 ∞ 的红利。

[2] ln(1+x) = Σ(−1)^{n+1} xⁿ/n(收敛半径 = 1)
       x     100 项部分和       cmath log(1+x)       误差
------------------------------------------------------------
     0.3         0.2623642645         0.2623642645    1.110e-16
     0.5         0.4054651081         0.4054651081    1.110e-16
     0.9         0.6418537610         0.6418538862    1.252e-07
     1.0         0.6881721793         0.6931471806    4.975e-03
     2.0 -8422741042710953197123403776.0000000000         1.0986122887    8.423e+27
    x=0.9 勉强收敛、x=1 缓慢发散边缘、x=2 完全发散 —— 收敛半径
    不是理论装饰,而是“这个算法能不能用”的分界线。

[3] 应对策略:换展开点。ln(2) = ln(1+0.5)+ln(1+0.333)…
    实用公式 ln 2 = 2·[0.5 + 0.5³/3 + 0.5⁵/5 + …]:
    30 项得 ln 2 ≈ 1.098612288668(cmath: 0.693147180560)✓

要点解析:ex 级数在 x=10 时仍到机器精度;ln(1+x) 在 x=0.9 收敛勉强、x=1 边缘挣扎、x=2 彻底发散。末尾的「换展开点」技巧(ln 2 用 0.5 的级数两倍)演示了工程师如何绕开收敛半径。

CASE 12.3 ex 的泰勒逼近图
数学:Tn(x) 局部逼近C++:SVG 绘图

把 1、3、5、7 阶泰勒多项式与 ex 本尊画在同一坐标系([-2.5, 2.5]):阶数每升一级,「贴合区间」就向外扩张一圈——局部逼近,全局扩张。

code/ch12c_taylor_svg.cpp(生成 SVG 需要 svgplot.hpp)下载源码 ↓
// ch12c_taylor_svg.cpp —— 实验 12.3:泰勒多项式的逼近图(生成 SVG)
// 数学:T_n(x) = Σ_{k=0}^{n} x^k/k!(e^x 的 n 阶泰勒多项式)
// 图形:n 越大,T_n 在更宽的区间上贴合 e^x —— “局部逼近,全局扩张”
#include "svgplot.hpp"
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>

double taylor(double x, int n) {
    double term = 1.0, sum = 1.0;
    for (int k = 1; k <= n; ++k) { term *= x / k; sum += term; }
    return sum;
}

int main() {
    printf("== 实验 12.3 e^x 的泰勒多项式逼近(绘图程序)==\n\n");

    // 采样:x ∈ [−2.5, 2.5]
    std::vector<std::pair<double, double>> fx, t1, t3, t5, t7;
    for (int i = 0; i <= 200; ++i) {
        double x = -2.5 + 5.0 * i / 200.0;
        fx.push_back({x, std::exp(x)});
        t1.push_back({x, taylor(x, 1)});
        t3.push_back({x, taylor(x, 3)});
        t5.push_back({x, taylor(x, 5)});
        t7.push_back({x, taylor(x, 7)});
    }

    SvgPlot pl(-2.5, 2.5, -2.0, 8.5, 680, 420);
    pl.open("ch12c_taylor.svg");
    pl.axes("x", "y");
    pl.plot(t7, "#7d5a2f", 1.2, "3,3", "7 阶");
    pl.plot(t5, "#b23a2e", 1.2, "3,3", "5 阶");
    pl.plot(t3, "#003b5c", 1.2, "3,3", "3 阶");
    pl.plot(t1, "#8a8578", 1.2, "3,3", "1 阶(切线)");
    pl.plot(fx, "#141414", 2.4, "", "e^x");
    pl.legend();
    pl.close();

    // 数值补充:中心 x=0 处各阶最大误差(在 |x|≤1 上)
    printf("在 [−1, 1] 上的最大逼近误差:\n");
    printf("%6s %14s\n", "阶数 n", "max |T_n − e^x|");
    printf("----------------------\n");
    for (int n : {1, 3, 5, 7, 9}) {
        double emax = 0.0;
        for (int i = 0; i <= 400; ++i) {
            double x = -1.0 + 2.0 * i / 400.0;
            emax = std::max(emax, std::fabs(taylor(x, n) - std::exp(x)));
        }
        printf("%6d %14.3e\n", n, emax);
    }
    printf("\n已生成 ch12c_taylor.svg:虚线为各阶多项式,实线为 e^x。\n");
    printf("观察:1 阶只在 0 点附近像切线;7 阶已把 e^x 抱在怀里 ——\n");
    printf("      “阶数换宽度”,这正是函数展开成级数的意义。\n");
    return 0;
}
▶ 编译运行输出
== 实验 12.3 e^x 的泰勒多项式逼近(绘图程序)==

在 [−1, 1] 上的最大逼近误差:
阶数 n max |T_n − e^x|
----------------------
     1      7.183e-01
     3      5.162e-02
     5      1.615e-03
     7      2.786e-05
     9      3.029e-07

已生成 ch12c_taylor.svg:虚线为各阶多项式,实线为 e^x。
观察:1 阶只在 0 点附近像切线;7 阶已把 e^x 抱在怀里 ——
      “阶数换宽度”,这正是函数展开成级数的意义。
e^x 的各阶泰勒多项式逼近曲线
FIG 12.1泰勒逼近(程序生成):虚线为 1/3/5/7 阶多项式,实线为 ex —— 1 阶是切线,7 阶已把指数函数「抱在怀里」。

要点解析:数值表给出 [−1,1] 上的最大误差:1 阶 ~0.718、3 阶 ~0.052、5 阶 ~0.0022、7 阶 ~0.00006、9 阶 ~1e-6 —— 误差被 xn+1/(n+1)! 步步压制,「阶数换宽度」明码标价。